JAVA_Stream_练习

package airycode_java8.nice7;

import airycode_java8.nice1.Employee;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * Created by admin on 2019/1/3.
 */
public class TestStramAPI {

    /***
     * 1.给定一个数字列表，如何返回一个由每一个数字的平方构成的列表,给定【1,2,3,4,5】返回[1,4,9,16,25]
     */
    @Test
    public void test1(){
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        List<Integer> collect = list.stream().map((x) -> x * x).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }

    /***
     * 2.用map和reduce方法数数流中有多少个emplloyee
     *
     */
    //准备数据
    static List<Employee> employeeList = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",38,5555.55,Employee.Status.BUSY),
            new Employee("王五",50,6666.66,Employee.Status.VOCATION),
            new Employee("赵六",16,3333.33,Employee.Status.FREE),
            new Employee("田七",8,7777.77,Employee.Status.BUSY)

    );
    @Test
    public void test2(){
        Optional<Integer> sum = employeeList.stream().map((e) -> 1).reduce(Integer::sum);
        System.out.println(sum.get());
    }

}

　　交易员和交易练习：

package airycode_java8.nice7;

/**
 * 交易员对象
 * Created by admin on 2019/1/3.
 */
public class Trader {

    private String name;
    private String city;

    public Trader(String name, String city) {
        this.name = name;
        this.city = city;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Trader{" +
                "name='" + name + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

package airycode_java8.nice7;

/**
 * 交易对象
 * Created by admin on 2019/1/3.
 */
public class Transaction {

    private Trader trader;
    private int year;
    private int value;
    private String currency;

    public Transaction(Trader trader,int year,int value,String currency){
        this.trader = trader;
        this.year = year;
        this.value = value;
        this.currency = currency;
    }

    public Trader getTrader(){
        return trader;
    }
    public int getYear(){
        return year;
    }
    public int getValue(){
        return value;
    }
    public String getCurrency(){
        return currency;
    }

    @Override
    public String toString(){
        return "i am transaction : my trader is : "
                + trader.getName()
                + " ; my year is : "
                + year
                + " ; my value is : "
                + value
                + " ; my currency is : "
                + currency;
    }
}

package airycode_java8.nice7;

import org.junit.Before;
import org.junit.Test;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

import static java.util.Comparator.comparingInt;
import static java.util.stream.Collectors.*;
/**
 * Created by admin on 2019/1/3.
 */
public class TraderExercise {

    List<Trader> traders = new LinkedList<>();
    List<Transaction> transactions = new LinkedList<>();

    @Before
    public void init(){

        Trader t1 = new Trader("trader1","剑桥");
        Trader t2 = new Trader("trader2","米兰");
        Trader t3 = new Trader("trader3","剑桥");
        Trader t4 = new Trader("trader4","剑桥");
        traders.addAll(Arrays.asList(t1,t2,t3,t4));

        Transaction tran1 = new Transaction(t4,2011,300,"$");
        Transaction tran2 = new Transaction(t1,2012,1000,"$");
        Transaction tran3 = new Transaction(t1,2011,400,"￥");
        Transaction tran4 = new Transaction(t2,2012,710,"￥");
        Transaction tran5 = new Transaction(t2,2012,700,"$");
        Transaction tran6 = new Transaction(t3,2012,950,"￥");
        transactions.addAll(Arrays.asList(tran1,tran2,tran3,tran4,tran5,tran6));
    }

    /***
     * 1.2011年的所有交易并按照金额由小到大排序
     */
    @Test
    public void test1(){
        transactions.stream()
                .filter((t)->t.getYear() == 2011)
                .sorted((t1,t2)->Integer.compare(t1.getValue(),t2.getValue()))
                .forEach(System.out::println);
    }

    /***
     *2.交易员都在哪些不同的城市生活
     */
    @Test
    public void test2(){

        traders.stream()
                .map(Trader::getCity)
                .distinct()
                .forEach(System.out::println);

    }

    /***
     *3.查找所有来自剑桥的交易员，并按姓名排序
     */
    @Test
    public void test3(){

//        traders.stream()
//                .filter((t)->"剑桥".equals(t.getCity()))
//                .sorted((e1,e2)->e1.getName().compareTo(e2.getName()))
//                .forEach(System.out::println);
        traders.stream()
                .filter((t)->"剑桥".equals(t.getCity()))
                .sorted(Comparator.comparing(Trader::getName))
                .forEach(System.out::println);

    }

    /***
     *4.查询所有交易员的姓名字符串，并按字母排序
     */
    @Test
    public void test4(){

        traders.stream()
                .filter((t)->"剑桥".equals(t.getCity()))
                .sorted(Comparator.comparing(Trader::getName))
                .forEach(System.out::println);

    }

    /***
     *5.有没有交易员在米兰
     */
    @Test
    public void test5(){

        boolean any = traders.stream()
                .filter((t) -> "米兰".equals(t.getCity()))
                .findAny()
                .isPresent();
        System.out.println(any);

    }

    /***
     * 6.打印在剑桥生活的交易员的所有交易金额
     */
    @Test
    public void test6(){

        Integer sum = transactions.stream()
                .filter(tran -> "剑桥".equals(tran.getTrader().getCity()))
                .map(Transaction::getValue)
                .reduce(0, (val1, val2) -> val1 + val2);
        System.out.println(sum);

    }

    /***
     * 7.所有交易中，最高的交易额是多少
     */
    @Test
    public void test7(){
        transactions.stream()
                .sorted(Comparator.comparing(Transaction::getValue).reversed())
                .findFirst()
                .ifPresent(System.out::println);

        transactions.stream()
                .map(Transaction::getValue)
                .reduce(Integer::max)
                .ifPresent(System.out::println);
    }

    /***
     * 8.找到交易额中最小的金额
     */
    @Test
    public void test8(){
        transactions.stream()
                .map(Transaction::getValue)
                .reduce(Integer::min)
                .ifPresent(System.out::println);

        transactions.stream()
                .min(Comparator.comparing(Transaction::getValue))
                .ifPresent(System.out::println);

        transactions.stream()
                .min(Comparator.comparing((Transaction t1) -> t1.getValue()))
                .ifPresent(System.out :: println);

    }

    /***
     * 9.统计每个交易员的记录
     */
    @Test
    public void test9(){
        transactions.stream()
                .collect(groupingBy(Transaction::getTrader))
                .entrySet().stream()
                .forEach(System.out::println);

    }

    /***
     * 10.找到单笔交易最高的交易员
     */
    @Test
    public void test10(){
        transactions.stream()
                .max(Comparator.comparing(Transaction::getValue))
                .ifPresent(tran->{
                    System.out.println(tran.getTrader());
                });
    }

    /***
     * 11.统计交易总额最高的交易员(排序)
     */
    @Test
    public void test11(){
        transactions.stream().collect(groupingBy(Transaction::getTrader))
                .entrySet().stream().map(t->{
            Map<String,Object> result = new HashMap<>();
            int sum = t.getValue().stream().mapToInt(Transaction :: getValue).sum();
            result.put("sum",sum);
            result.put("trader",t.getKey());
            return result;

        }).sorted(comparingInt((Map m) -> (int)m.get("sum")).reversed()).findFirst().ifPresent(System.out::println);
    }

    /***
     * 12.使用方法引用对transaction排序
     */
    @Test
    public void test12(){
        transactions.stream().sorted(Comparator.comparing(Transaction::getValue)).forEach(System.out::println);

        System.out.println("--------------------------------------------------------------------------------");

        //声明接口的实现方式
        Function<Transaction,Integer> function = Transaction :: getValue;
        Transaction[] transactionsArray = new Transaction[transactions.size()];
        Arrays.sort(transactions.toArray(transactionsArray),Comparator.comparing(function));
        Arrays.asList(transactionsArray).stream().forEach(System.out :: println);
    }

    /***
     * 13.根据trader(对象)将transaction分组
     */
    @Test
    public void test13(){
        transactions.stream()
                .collect(groupingBy(Transaction :: getTrader))
                .entrySet().stream()
                .forEach(System.out :: println);
    }

    //【14.根据货币（字符串）类型分组
    @Test
    public void exercise14(){
        transactions.stream()
                .collect(groupingBy(Transaction :: getCurrency))
                .entrySet().stream()
                .forEach(System.out :: println);
    }
    //【15.获取交易总金额
    @Test
    public void exercise15(){
        int sum1 = transactions.stream().mapToInt(Transaction::getValue).sum();
        System.out.println("通过map转换求和sum1 = " + sum1);
        int sum2 = transactions.stream().collect(Collectors.summingInt(Transaction::getValue));
        System.out.println("通过collect汇总求和sum2 = " + sum2);
        //规约操作都需要使用map将对象映射为返回值的类型
        int sum3 = transactions.stream().map(Transaction::getValue).reduce(0,(t1,t2) -> t1 + t2);
        System.out.println("通过reduce规约求和sum3 = " + sum3);
    }
    //【16.二级分类，先按照交易员分类，然后交易金额大于800归为high，低于800归为low
    @Test
    public void exercise16(){
        transactions.stream()
                .collect(groupingBy(Transaction :: getTrader,groupingBy(t -> {
                    if(t.getValue()< 800 ){
                        return "low";
                    }else {
                        return "heigh";
                    }
                })))
                .entrySet().stream()
                .forEach(System.out :: println);
    }
    //【17.获取每个交易员，交易最大的一笔
    @Test
    public void exercise17(){
        transactions.stream()
                .collect(groupingBy(Transaction::getTrader,maxBy(Comparator.comparingInt(Transaction::getValue))))
                .entrySet().stream()
                .distinct()
                .sorted(Comparator.comparing((Map.Entry m) -> {
                    Trader t = (Trader) m.getKey();
                    return t.getName();
                }))
                .forEach(System.out :: println);
    }

}