摘要：交易員練習(xí)年的所有交易并按照金額由小到大排序交易員都在哪些不同的城市生活查找所有來(lái)自劍橋的交易員，并按姓名排序劍橋查詢所有交易員的姓名字符串，并按字母排序有沒有交易員在米蘭米蘭打印在劍橋生活的交易員的所有交易金額劍橋所有交易中，

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交易員練習(xí)
 */
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.查找所有來(lái)自劍橋的交易員，并按姓名排序
    @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.統(tǒng)計(jì)每個(gè)交易員的記錄
    @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.統(tǒng)計(jì)交易總額最高的交易員(排序)
    @Test
    public void exercise11(){
        transactions.stream()
                .collect(groupingBy(Transaction :: getTrader))
                .entrySet().stream()
                .map( t -> {
                    Map 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.使用方法引用對(duì)transaction排序
    @Test
    public void exercise12(){
        transactions.stream()
                .sorted(Comparator.comparing(Transaction :: getValue))
                .forEach(System.out :: println);

        System.out.println("------------------------------------------");
        //聲明接口的的實(shí)現(xiàn)方式
        Function 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.根據(jù)trader(對(duì)象)將transaction分組
    @Test
    public void exercise13(){
        transactions.stream()
                .collect(groupingBy(Transaction :: getTrader))
                .entrySet().stream()
                .forEach(System.out :: println);
    }
    //【14.根據(jù)貨幣（字符串）類型分組
    @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轉(zhuǎn)換求和sum1 = " + sum1);
        int sum2 = transactions.stream().collect(Collectors.summingInt(Transaction::getValue));
        System.out.println("通過collect匯總求和sum2 = " + sum2);
        //規(guī)約操作都需要使用map將對(duì)象映射為返回值的類型
        int sum3 = transactions.stream().map(Transaction::getValue).reduce(0,(t1,t2) -> t1 + t2);
        System.out.println("通過reduce規(guī)約求和sum3 = " + sum3);
    }
    //【16.二級(jí)分類，先按照交易員分類，然后交易金額大于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.獲取每個(gè)交易員，交易最大的一筆
    @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);
    }

    //===================================初始化數(shù)據(jù)================================
    List traders = new LinkedList<>();
    List 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));
    }

    //交易員對(duì)象
    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;
        }
    }
    //交易對(duì)象
    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;
        }
    }

}