全面吃透JAVA Stream流操作，讓程式碼更加的優雅

全面吃透JAVA Stream流操作，讓程式碼更加的優雅
☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝

在JAVA中，涉及到對陣列、Collection等集合類中的元素進行操作的時候，通常會通過迴圈的方式進行逐個處理，或者使用Stream的方式進行處理。

例如，現在有這麼一個需求：

從給定句子中返回單詞長度大於5的單詞列表，按長度倒序輸出，最多返回3個

在JAVA7及之前的程式碼中，我們會可以照如下的方式進行實現：


/**
 * 【常規方式】
 * 從給定句子中返回單詞長度大於5的單詞列表，按長度倒序輸出，最多返回3個
 *
 * @param sentence 給定的句子，約定非空，且單詞之間僅由一個空格分隔
 * @return 倒序輸出符合條件的單詞列表
 */
public List<String> sortGetTop3LongWords(@NotNull String sentence) {
    // 先切割句子，獲取具體的單詞資訊
    String[] words = sentence.split(" ");
    List<String> wordList = new ArrayList<>();
    // 迴圈判斷單詞的長度，先過濾出符合長度要求的單詞
    for (String word : words) {
        if (word.length() > 5) {
            wordList.add(word);
        }
    }
    // 對符合條件的列表按照長度進行排序
    wordList.sort((o1, o2) -> o2.length() - o1.length());
    // 判斷list結果長度，如果大於3則擷取前三個資料的子list返回
    if (wordList.size() > 3) {
        wordList = wordList.subList(0, 3);
    }
    return wordList;
}

在JAVA8及之後的版本中，藉助Stream流，我們可以更加優雅的寫出如下程式碼：


/**
 * 【Stream方式】
 * 從給定句子中返回單詞長度大於5的單詞列表，按長度倒序輸出，最多返回3個
 *
 * @param sentence 給定的句子，約定非空，且單詞之間僅由一個空格分隔
 * @return 倒序輸出符合條件的單詞列表
 */
public List<String> sortGetTop3LongWordsByStream(@NotNull String sentence) {
    return Arrays.stream(sentence.split(" "))
            .filter(word -> word.length() > 5)
            .sorted((o1, o2) -> o2.length() - o1.length())
            .limit(3)
            .collect(Collectors.toList());
}

直觀感受上，Stream的實現方式程式碼更加簡潔、一氣呵成。很多的同學在程式碼中也經常使用Stream流，但是對Stream流的認知往往也是僅限於會一些簡單的filter、map、collect等操作，但JAVA的Stream可以適用的場景與能力遠不止這些。

那麼問題來了：Stream相較於傳統的foreach的方式處理stream，到底有啥優勢？

這裡我們可以先擱置這個問題，先整體全面的瞭解下Stream，然後再來討論下這個問題。

筆者結合在團隊中多年的程式碼檢視遇到的情況，結合平時專案編碼實踐經驗，對Stream的核心要點與易混淆用法、典型使用場景等進行了詳細的梳理總結，希望可以幫助大家對Stream有個更全面的認知，也可以更加高效的應用到專案開發中去。

Stream初相識

概括講，可以將Stream流操作分為3種型別：

建立Stream
Stream中間處理
終止Steam

每個Stream管道操作型別都包含若干API方法，先列舉下各個API方法的功能介紹。

開始管道

主要負責新建一個Stream流，或者基於現有的陣列、List、Set、Map等集合型別物件建立出新的Stream流。

API	功能說明
stream()	建立出一個新的stream序列流物件
parallelStream()	建立出一個可並行執行的stream流物件
Stream.of()	通過給定的一系列元素建立一個新的Stream序列流物件

中間管道

負責對Stream進行處理操作，並返回一個新的Stream物件，中間管道操作可以進行疊加。

API	功能說明
filter()	按照條件過濾符合要求的元素，返回新的stream流
map()	將已有元素轉換為另一個物件型別，一對一邏輯，返回新的stream流
flatMap()	將已有元素轉換為另一個物件型別，一對多邏輯，即原來一個元素物件可能會轉換為1個或者多個新型別的元素，返回新的stream流
limit()	僅保留集合前面指定個數的元素，返回新的stream流
skip()	跳過集合前面指定個數的元素，返回新的stream流
concat()	將兩個流的資料合併起來為1個新的流，返回新的stream流
distinct()	對Stream中所有元素進行去重，返回新的stream流
sorted()	對stream中所有的元素按照指定規則進行排序，返回新的stream流
peek()	對stream流中的每個元素進行逐個遍歷處理，返回處理後的stream流

終止管道

顧名思義，通過終止管道操作之後，Stream流將會結束，最後可能會執行某些邏輯處理，或者是按照要求返回某些執行後的結果資料。

API	功能說明
count()	返回stream處理後最終的元素個數
max()	返回stream處理後的元素最大值
min()	返回stream處理後的元素最小值
findFirst()	找到第一個符合條件的元素時則終止流處理
findAny()	找到任何一個符合條件的元素時則退出流處理，這個對於序列流時與findFirst相同，對於並行流時比較高效，任何分片中找到都會終止後續計算邏輯
anyMatch()	返回一個boolean值，類似於isContains(),用於判斷是否有符合條件的元素
allMatch()	返回一個boolean值，用於判斷是否所有元素都符合條件
noneMatch()	安徽一個boolean值，用於判斷是否所有元素都不符合條件
collect()	將流轉換為指定的型別，通過Collectors進行指定
toArray()	將流轉換為陣列
iterator()	將流轉換為Iterator物件
foreach()	無返回值，對元素進行逐個遍歷，然後執行給定的處理邏輯

Stream方法使用

map與flatMap

map與flatMap都是用於轉換已有的元素為其它元素，區別點在於：

map 必須是一對一的，即每個元素都只能轉換為1個新的元素
flatMap 可以是一對多的，即每個元素都可以轉換為1個或者多個新的元素

比如：有一個字串ID列表，現在需要將其轉為User物件列表。可以使用map來實現：


/**
 * 演示map的用途：一對一轉換
 */
public void stringToIntMap() {
    List<String> ids = Arrays.asList("205","105","308","469","627","193","111");
    // 使用流操作
    List<Integer> results = ids.stream()
            .map(s -> Integer.valueOf(s))
            .collect(Collectors.toList());
    System.out.println(results);
}

執行之後，會發現每一個元素都被轉換為對應新的元素，但是前後總元素個數是一致的：


[User{id='205'}, 
 User{id='105'},
 User{id='308'}, 
 User{id='469'}, 
 User{id='627'}, 
 User{id='193'}, 
 User{id='111'}]

再比如：現有一個句子列表，需要將句子中每個單詞都提取出來得到一個所有單詞列表。這種情況用map就搞不定了，需要flatMap上場了：


public void stringToIntFlatmap() {
    List<String> sentences = Arrays.asList("hello world","Jia Gou Wu Dao");
    // 使用流操作
    List<String> results = sentences.stream()
            .flatMap(sentence -> Arrays.stream(sentence.split(" ")))
            .collect(Collectors.toList());
    System.out.println(results);
}

執行結果如下，可以看到結果列表中元素個數是比原始列表元素個數要多的：


[hello, world, Jia, Gou, Wu, Dao]

這裡需要補充一句，flatMap操作的時候其實是先每個元素處理並返回一個新的Stream，然後將多個Stream展開合併為了一個完整的新的Stream，如下：

peek和foreach方法

peek和foreach，都可以用於對元素進行遍歷然後逐個的進行處理。

但根據前面的介紹，peek屬於中間方法，而foreach屬於終止方法。這也就意味著peek只能作為管道中途的一個處理步驟，而沒法直接執行得到結果，其後面必須還要有其它終止操作的時候才會被執行；而foreach作為無返回值的終止方法，則可以直接執行相關操作。


public void testPeekAndforeach() {
    List<String> sentences = Arrays.asList("hello world","Jia Gou Wu Dao");
    // 演示點1： 僅peek操作，最終不會執行
    System.out.println("----before peek----");
    sentences.stream().peek(sentence -> System.out.println(sentence));
    System.out.println("----after peek----");
    // 演示點2： 僅foreach操作，最終會執行
    System.out.println("----before foreach----");
    sentences.stream().forEach(sentence -> System.out.println(sentence));
    System.out.println("----after foreach----");
    // 演示點3： peek操作後面增加終止操作，peek會執行
    System.out.println("----before peek and count----");
    sentences.stream().peek(sentence -> System.out.println(sentence)).count();
    System.out.println("----after peek and count----");
}

輸出結果可以看出，peek獨自呼叫時並沒有被執行、但peek後面加上終止操作之後便可以被執行，而foreach可以直接被執行：


----before peek----
----after peek----
----before foreach----
hello world
Jia Gou Wu Dao
----after foreach----
----before peek and count----
hello world
Jia Gou Wu Dao
----after peek and count----

filter、sorted、distinct、limit

這幾個都是常用的Stream的中間操作方法，具體的方法的含義在上面的表格裡面有說明。具體使用的時候，可以根據需要選擇一個或者多個進行組合使用，或者同時使用多個相同方法的組合：


public void testGetTargetUsers() {
    List<String> ids = Arrays.asList("205","10","308","49","627","193","111", "193");
    // 使用流操作
    List<Dept> results = ids.stream()
            .filter(s -> s.length() > 2)
            .distinct()
            .map(Integer::valueOf)
            .sorted(Comparator.comparingInt(o -> o))
            .limit(3)
            .map(id -> new Dept(id))
            .collect(Collectors.toList());
    System.out.println(results);
}

上面的程式碼片段的處理邏輯很清晰：

使用filter過濾掉不符合條件的資料
通過distinct對存量元素進行去重操作
通過map操作將字串轉成整數型別
藉助sorted指定按照數位大小正序排列
使用limit擷取排在前3位的元素
又一次使用map將id轉為Dept物件型別
使用collect終止操作將最終處理後的資料收集到list中

輸出結果：

[Dept{id=111},  Dept{id=193},  Dept{id=205}]

簡單結果終止方法

按照前面介紹的，終止方法裡面像count、max、min、findAny、findFirst、anyMatch、allMatch、nonneMatch等方法，均屬於這裡說的簡單結果終止方法。所謂簡單，指的是其結果形式是數位、布林值或者Optional物件值等。


public void testSimpleStopOptions() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    // 統計stream操作後剩餘的元素個數
    System.out.println(ids.stream().filter(s -> s.length() > 2).count());
    // 判斷是否有元素值等於205
    System.out.println(ids.stream().filter(s -> s.length() > 2).anyMatch("205"::equals));
    // findFirst操作
    ids.stream().filter(s -> s.length() > 2)
            .findFirst()
            .ifPresent(s -> System.out.println("findFirst:" + s));
}

執行後結果為：


6
true
findFirst:205

避坑提醒

這裡需要補充提醒下，一旦一個Stream被執行了終止操作之後，後續便不可以再讀這個流執行其他的操作了，否則會報錯，看下面範例：


public void testHandleStreamAfterClosed() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    Stream<String> stream = ids.stream().filter(s -> s.length() > 2);
    // 統計stream操作後剩餘的元素個數
    System.out.println(stream.count());
    System.out.println("-----下面會報錯-----");
    // 判斷是否有元素值等於205
    try {
        System.out.println(stream.anyMatch("205"::equals));
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("-----上面會報錯-----");
}

執行的時候，結果如下：


6
-----下面會報錯-----
java.lang.IllegalStateException: stream has already been operated upon or closed
	at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
	at java.util.stream.ReferencePipeline.anyMatch(ReferencePipeline.java:449)
	at com.veezean.skills.stream.StreamService.testHandleStreamAfterClosed(StreamService.java:153)
	at com.veezean.skills.stream.StreamService.main(StreamService.java:176)
-----上面會報錯-----

因為stream已經被執行count()終止方法了，所以對stream再執行anyMatch方法的時候，就會報錯stream has already been operated upon or closed，這一點在使用的時候需要特別注意。

結果收集終止方法

因為Stream主要用於對集合資料的處理場景，所以除了上面幾種獲取簡單結果的終止方法之外，更多的場景是獲取一個集合類的結果物件，比如List、Set或者HashMap等。

這裡就需要collect方法出場了，它可以支援生成如下型別的結果資料：

一個集合類，比如List、Set或者HashMap等
StringBuilder物件，支援將多個字串進行拼接處理並輸出拼接後結果
一個可以記錄個數或者計算總和的物件（資料批次運算統計）

生成集合

應該算是collect最常被使用到的一個場景了：


public void testCollectStopOptions() {
    List<Dept> ids = Arrays.asList(new Dept(17), new Dept(22), new Dept(23));
    // collect成list
    List<Dept> collectList = ids.stream().filter(dept -> dept.getId() > 20)
            .collect(Collectors.toList());
    System.out.println("collectList:" + collectList);
    // collect成Set
    Set<Dept> collectSet = ids.stream().filter(dept -> dept.getId() > 20)
            .collect(Collectors.toSet());
    System.out.println("collectSet:" + collectSet);
    // collect成HashMap，key為id，value為Dept物件
    Map<Integer, Dept> collectMap = ids.stream().filter(dept -> dept.getId() > 20)
            .collect(Collectors.toMap(Dept::getId, dept -> dept));
    System.out.println("collectMap:" + collectMap);
}

結果如下：


collectList:[Dept{id=22}, Dept{id=23}]
collectSet:[Dept{id=23}, Dept{id=22}]
collectMap:{22=Dept{id=22}, 23=Dept{id=23}}

生成拼接字串

將一個List或者陣列中的值拼接到一個字串裡並以逗號分隔開，這個場景相信大家都不陌生吧？

如果通過for迴圈和StringBuilder去迴圈拼接，還得考慮下最後一個逗號如何處理的問題，很繁瑣:


public void testForJoinStrings() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    StringBuilder builder = new StringBuilder();
    for (String id : ids) {
        builder.append(id).append(',');
    }
    // 去掉末尾多拼接的逗號
    builder.deleteCharAt(builder.length() - 1);
    System.out.println("拼接後：" + builder.toString());
}

但是現在有了Stream，使用collect可以輕而易舉的實現：


public void testCollectJoinStrings() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    String joinResult = ids.stream().collect(Collectors.joining(","));
    System.out.println("拼接後：" + joinResult);
}

兩種方式都可以得到完全相同的結果，但Stream的方式更優雅：

拼接後：205,10,308,49,627,193,111,193

資料批次數學運算

還有一種場景，實際使用的時候可能會比較少，就是使用collect生成數位資料的總和資訊，也可以瞭解下實現方式：


public void testNumberCalculate() {
    List<Integer> ids = Arrays.asList(10, 20, 30, 40, 50);
    // 計算平均值
    Double average = ids.stream().collect(Collectors.averagingInt(value -> value));
    System.out.println("平均值：" + average);
    // 資料統計資訊
    IntSummaryStatistics summary = ids.stream().collect(Collectors.summarizingInt(value -> value));
    System.out.println("資料統計資訊： " + summary);
}

上面的例子中，使用collect方法來對list中元素值進行數學運算，結果如下：


平均值：30.0
總和： IntSummaryStatistics{count=5, sum=150, min=10, average=30.000000, max=50}

並行Stream

機制說明

使用並行流，可以有效利用計算機的多CPU硬體，提升邏輯的執行速度。並行流通過將一整個stream劃分為多個片段，然後對各個分片流並行執行處理邏輯，最後將各個分片流的執行結果彙總為一個整體流。

約束與限制

並行流類似於多執行緒在並行處理，所以與多執行緒場景相關的一些問題同樣會存在，比如死鎖等問題，所以在並行流終止執行的函數邏輯，必須要保證執行緒安全。

回答最初的問題

到這裡，關於JAVA Stream的相關概念與用法介紹，基本就講完了。我們再把焦點切回本文剛開始時提及的一個問題：

Stream相較於傳統的foreach的方式處理stream，到底有啥優勢？

根據前面的介紹，我們應該可以得出如下幾點答案：

程式碼更簡潔、偏宣告式的編碼風格，更容易體現出程式碼的邏輯意圖
邏輯間解耦，一個stream中間處理邏輯，無需關注上游與下游的內容，只需要按約定實現自身邏輯即可
並行流場景效率會比迭代器逐個迴圈更高
函數式介面，延遲執行的特性，中間管道操作不管有多少步驟都不會立即執行，只有遇到終止操作的時候才會開始執行，可以避免一些中間不必要的操作消耗

當然了，Stream也不全是優點，在有些方面也有其弊端：

程式碼調測debug不便
程式設計師從歷史寫法切換到Stream時，需要一定的適應時間

總結

好啦，關於JAVA Stream的理解要點與使用技能的闡述就先到這裡啦。那通過上面的介紹，各位小夥伴們是否已經躍躍欲試了呢？快去專案中使用體驗下吧！當然啦，如果有疑問，也歡迎找我一起探討探討咯。

此外：

關於Stream中collect的分組、分片等進階操作，以及對並行流的深入探討，因為涉及內容比較多且相對獨立，我會在後續的檔案中展開專門介紹下，如果有興趣的話，可以點個關注、避免迷路。
關於本文中涉及的演示程式碼的完整範例，我已經整理並提交到github中，如果您有需要，可以自取：https://github.com/veezean/JavaBasicSkills

我是悟道，聊技術、又不僅僅聊技術~

如果覺得有用，請點個關注，也可以關注下我的公眾號【架構悟道】，獲取更及時的更新。

期待與你一起探討，一起成長為更好的自己。