Java 流處理

流是jdk8新增的一個特性。大概可以理解為將集合轉為流，處理之后再轉換成自己想要的其他類型。

對流的操作大概可以分成兩類，中間操作和結束操作。

每次調用中間操作都會生成一個新的流，當結束操作執行時會觸發實際運算，計算完成之后流就會失效。

Java的優點：

Stream不是一個數據結構，它應該可以說是數據源的視圖，數據源可以是Java容器，數組等等。

Stream是惰式操作，Stream的操作並不會真正運行，而是要等到用戶需要結果的時候才會運行

為函數編程而生。對stream的任何修改都不會影響背后的數據源，比如對Stream進行數據過濾操作並不會刪除不符合條件的元素，而是會生成一個包含符合條件元素的新Stream。

可消費性。Stream只能被使用一次，一旦遍歷之后就會失效，就像迭代器那樣，需要使用就需要再次生成。

下面是一個網上的例子，我加了自己理解的注解。

public static void main(String[] args) {
    Trader raoul = new Trader("raoul", "Cambridge");
    Trader mario = new Trader("mario", "Milan");
    Trader alan = new Trader("alan", "Cambridge");
    Trader brian = new Trader("brian", "Cambridge");
    //交易記錄
    List<Transaction> transactions = Arrays.asList(
            new Transaction(brian, 2011, 300),
            new Transaction(raoul, 2012, 1000),
            new Transaction(raoul, 2011, 400),
            new Transaction(mario, 2012, 710),
            new Transaction(mario, 2012, 700),
            new Transaction(alan, 2012, 950));

    //找出2011年發生的所有交易，並按金額從低到高排序
    //先過濾出時間不是2011的
    Stream<Transaction> transactionStream = transactions.stream().filter((t) -> t.getYear() == 2011);
    // 從低到高價格排序  最后把流轉換成集合
    List<Transaction> collect = transactionStream.sorted(Comparator.comparing(Transaction::getValue)).collect(Collectors.toList());
     
    //將集合轉換成流來進行分組 會得到一個map集合。
    Map<Integer, Long> collect2 = transactions.stream().collect(Collectors.groupingBy(Transaction::getYear, Collectors.counting()));


    //查看交易員在哪些城市
    //先從集合中映射出交易員 再映射出城市名 再去重 再轉成集合
    List<String> collect3 = transactions.stream().map(Transaction::getTrader).map(Trader::getCity).distinct().collect(Collectors.toList());
    collect.forEach(System.out::println);

    //查找出所有來自劍橋的員工 並按姓名排序
    //先映射出交易員 再映射出城市名 再過濾 再排序 再轉換
    List<Trader> collect4 = transactions.stream().map(Transaction::getTrader).filter((t) -> t.getCity().equals("Cambridge")).distinct().sorted(Comparator.comparing(Trader::getName)).collect(Collectors.toList());

    //返回所有交易員的姓名字符串 並按姓名排序
    // a一開始變量為 "" 使用一個字符串相加  最后結果一定是字符串。
    //一個集合里求和的常用邏輯為 ""為list[0]  list[0]+list[1]+list[2]+....list[n-1]
    String reduce = transactions.stream().map((t) -> t.getTrader().getName()).sorted().reduce("", (a, b) -> a + b);
    System.out.println(reduce);

    //有沒有交易員在米蘭工作過
    //先映射出交易員 再匹配有沒有城市是milan
    boolean milan = transactions.stream().map(Transaction::getTrader).anyMatch(t -> t.getCity().equals("Milan"));
    System.out.println("有沒有員工在米蘭工作過:" + milan);

    //打印所有在劍橋的交易員的所有交易額 2650
    //先過濾掉城市不是劍橋的 然后映射出Value 最后取和
    transactions.stream().filter(t->t.getTrader().getCity().equals("Cambridge")).map(Transaction::getValue).reduce(0,(a,b)->a+b);

    //所有得交易額中 最高的交易額
    //先對交易額進行排序（reversed()降序） 然后映射出交易額 取第一個
    List<Integer> collect1 = transactions.stream().sorted(Comparator.comparing(Transaction::getValue).reversed()).map(Transaction::getValue).limit(1).collect(Collectors.toList());
    //升級
    transactions.stream().map(Transaction::getValue).reduce(Integer::max);
    //升級
    transactions.stream().max(Comparator.comparing(Transaction::getValue));

    //找到最小的交易額
    transactions.stream().map(Transaction::getValue).reduce(Integer::min);
    //升級
    transactions.stream().min(Comparator.comparing(Transaction::getValue));
}