java8-stream經常使用操做

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;
        }
    }

}