java8交易员练习

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 ibm on 2017/4/12.
 * java8交易员练习
 */
public class TraderExercise {

    //【1.2011年的所有交易并按照金额由小到大排序
    @Test
    public void exercise1(){
        transactions.stream()
                .filter(t -> t.getYear() == 2011)
                .sorted(Comparator.comparing(Transaction::getValue))
                .forEach(System.out :: println);
    }
    //【2.交易员都在哪些不同的城市生活
    @Test
    public void exercise2(){
        traders.stream()
                .map(Trader :: getCity)
                .distinct()
                .forEach(System.out :: println);
    }
    //【3.查找所有来自剑桥的交易员，并按姓名排序
    @Test
    public void exercise3(){
        traders.stream()
                .filter( t -> "剑桥".equals(t.getCity()))
                .sorted(Comparator.comparing(Trader :: getName))
                .forEach(System.out :: println);
    }
    //【4.查询所有交易员的姓名字符串，并按字母排序
    @Test
    public void exercise4(){
        traders.stream()
                .sorted(Comparator.comparing(Trader :: getName).reversed())
                .forEach(t -> System.out.println(t.getName()));
    }
    //【5.有没有交易员在米兰
    @Test
    public void exercise5(){
        traders.stream()
                .filter(t -> "米兰".equals(t.getCity()))
                .findAny()
                .ifPresent(System.out :: println);
    }
    //【6.打印在剑桥生活的交易员的所有交易金额
    @Test
    public void exercise6(){
        int sumValue = transactions.stream()
                .filter(tran -> "剑桥".equals(tran.getTrader().getCity()))
                .map(Transaction::getValue)
                .reduce(0,(value1 , value2) -> value1 + value2);
        System.out.println(sumValue);
    }
    //【7.所有交易中，最高的交易额是多少
    @Test
    public void exercise7(){
         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 exercise8(){
        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 exercise9(){
        transactions.stream()
                .collect(groupingBy(Transaction :: getTrader))
                .entrySet().stream()
                .forEach(System.out :: println);
    }
    //【10.找到单笔交易最高的交易员
    @Test
    public void exercise(){
        transactions.stream()
                .max(Comparator.comparing(Transaction :: getValue))
                .ifPresent( tran -> {
                    System.out.println(tran.getTrader());
                } );
    }
    //【11.统计交易总额最高的交易员(排序)
    @Test
    public void exercise11(){
        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 exercise12(){
        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 exercise13(){
        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);
    }

    //===================================初始化数据================================
    List<Trader> traders = new LinkedList<>();
    List<Transaction> transactions = new LinkedList<>();

    public TraderExercise(){
        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));
    }

    //交易员对象
    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 String getCity(){
            return city;
        }

        @Override
        public String toString(){
           return "i am trader : " + name + " ; i live in : " + city;
        }
    }
    //交易对象
    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;
        }
    }

}