熱門系列：
目錄
2.2.5 非短路（Unshort-circuiting）操作
1.前言
Java 8的另一大亮點Stream，它與 java.io 包裏的 InputStream 和 OutputStream 是完全不同的概念。
Java 8 中的 Stream 是對集合（Collection）對象功能的增強，它專注於對集合對象進行各種非常便利、高效的聚合操作（aggregate operation），或者大批量數據操作 (bulk data operation)。
Stream API 藉助於同樣新出現的 Lambda 表達式，極大的提高編程效率和程序可讀性。同時它提供串行和並行兩種模式進行匯聚操作，併發模式能夠充分利用多核處理器的優勢，使用 fork/join 並行方式來拆分任務和加速處理過程。
1.1 爲什麼要用Stream
我個人總結有如下幾個特點：
- 有高效率的並行操作
- 有多中功能性的聚合操作
- 函數式編程，使代碼更加簡潔，提高編程效率
1.2 什麼是聚合操作
舉個例子，例如我們現在有一個模塊的列表需要做如下處理：
- 客戶每月平均消費金額
- 最昂貴的在售商品
- 本週完成的有效訂單（排除了無效的）
- 取十個數據樣本作爲首頁推薦
以上這些操作，你可以理解爲就是對一個列表集合的聚合操作啦，類似於SQL裏面的（count（）、sum(）、avg（）....）！
有一些操作，有人可能會說，可以在SQL語句中完成過濾分類！首先不說SQL不能實現的功能，即使SQL能夠實現，但是數據庫畢竟是用來讀寫數據的，主要功能是用於數據落地存儲的。並不是用來做大量的邏輯處理的，所以不能爲了圖方便，而忽略了性能方面的損耗！所以，相比之下，有一些列表操作我們必須在程序中做邏輯處理！那如果我們用之前的java處理方式，得像如下操作一樣：
那如果用Stream來處理的話，可能就只有如下簡單幾行：
list.stream().filter().limit(10).foreach();
所以，代碼不僅簡潔了，閱讀起來也會很是方便！
2.正文
2.1 Stream操作分類
Stream的操作可以分爲兩大類：中間操作、終結操作
中間操作可分爲：
- 無狀態（Stateless）操作：指元素的處理不受之前元素的影響
- 有狀態（Stateful）操作：指該操作只有拿到所有元素之後才能繼續下去
終結操作可分爲：
- 短路（Short-circuiting）操作：指遇到某些符合條件的元素就可以得到最終結果
- 非短路（Unshort-circuiting）操作：指必須處理完所有元素才能得到最終結果
Stream結合具體操作，大致可分爲如下圖所示：
2.2 Stream API使用
接下來，我們將按各種類型的操作，對一些常用的功能API進行一一講解：
2.2.1 Stream 構成與創建
2.2.1.1 流的構成
當我們使用一個流的時候，通常包括三個基本步驟：
獲取一個數據源（source）→ 數據轉換 → 執行操作獲取想要的結果，每次轉換原有 Stream 對象不改變，返回一個新的 Stream 對象（可以有多次轉換），這就允許對其操作可以像鏈條一樣排列，變成一個管道。
如下圖所示：
2.2.1.2 流的創建
- 通過
java.util.Collection.stream()方法用集合創建流
- 使用
java.util.Arrays.stream(T[] array)方法用數組創建流
Stream的靜態方法：of()、iterate()、generate()
stream和parallelStream的簡單區分
stream是順序流，由主線程按順序對流執行操作，而parallelStream是並行流，內部以多線程並行執行的方式對流進行操作，需要注意使用並行流的前提是流中的數據處理沒有順序要求（會亂序，即使用了forEachOrdered）。例如篩選集合中的奇數，兩者的處理不同之處：
當然，除了直接創建並行流，還可以通過parallel()把順序流轉換成並行流：
Optional<Integer> findFirst = list.stream().parallel().filter(x->x>4).findFirst();
2.2.2 無狀態（Stateless）操作
- filter：篩選，是按照一定的規則校驗流中的元素，將符合條件的元素提取到新的流中的操作。
Stream<T> filter(Predicate<? super T> predicate);
流程解析圖如下：
舉個栗子：
- 映射(map、flatMap、peek)
①map：一個元素類型爲 T 的流轉換成元素類型爲 R 的流，這個方法傳入一個Function的函數式接口，接收一個泛型T，返回泛型R，map函數的定義，返回的流，表示的泛型是R對象；
簡言之：將集合中的元素A轉換成想要得到的B
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
流程解析圖如下：
舉個栗子：
或如下（衆多姿勢，任君選擇）：
②flatMap：接收一個函數作爲參數，將流中的每個值都換成另一個流，然後把所有流連接成一個流。
簡言之：與Map功能類似，區別在於將結合A的流轉換成B流
流程解析圖如下：
舉個栗子：
③peek：peek 操作接收的是一個 Consumer<T> 函數。顧名思義 peek 操作會按照 Consumer<T> 函數提供的邏輯去消費流中的每一個元素，同時有可能改變元素內部的一些屬性。
Stream<T> peek(Consumer<? super T> action);
這裏我們要提一下這個 Consumer<T> ，以理解什麼是消費。
Consumer<T> 是一個函數接口。一個抽象方法 void accept(T t) 意爲接受一個 T 類型的參數並將其消費掉。其實消費給我的感覺就是 “用掉” ，自然返回的就是 void 。通常“用掉” T 的方式爲兩種：
T 本身的 void 方法 比較典型的就是
setter。把 T 交給其它接口（類）的 void 方法進行處理 比如我們經常用的打印一個對象
System.out.println(T)
操作流程解析圖如下：
下面我們來看個栗子：
執行之後，控制檯並沒有輸出任何字符串！納尼？？
這是因爲流的生命週期有三個階段：
-
起始生成階段。
-
中間操作會逐一獲取元素並進行處理。可有可無。所有中間操作都是惰性的，因此，流在管道中流動之前，任何操作都不會產生任何影響。
-
終端操作。通常分爲 最終的消費 （
foreach之類的）和 歸納 （collect）兩類。還有重要的一點就是終端操作啓動了流在管道中的流動。
所以，上面的代碼是因爲缺少了終端操作，因此，我們改成如下即可：
重點：peek VS map
他們最大的區別是：
peek操作 一般用於不想改變流中元素本身的類型或者只想元素的內部狀態時；而
map則用於改變流中元素本身類型，即從元素中派生出另一種類型的操作。
④mapToInt、mapToLong、mapToDouble、flatMapToDouble、flatMapToInt、flatMapToLong
以上這些操作是map和flatMap的特例版，也就是針對特定的數據類型進行映射處理。其對應的方法接口如下：
此處就不全部單獨說明了，取一個操作舉例說明一下其用法：
並且這些指定類型的流，還有另外一些常用的方法，也是很好用的，可以參考：IntStream、LongStream、DoubleStream
- 無序化（unordered）
unordered()操作不會執行任何操作來顯式地對流進行排序。它的作用是消除了流必須保持有序的約束，從而允許後續操作使用不必考慮排序的優化。
舉個栗子：
以上結果，可以看到，雖然用了unordered()，但是第一個循環裏的數據順序並沒有被打亂；是不是很好奇？
您可以在Java 8文檔中有一下一段內容：
對於順序流，順序的存在與否不會影響性能，隻影響確定性。如果流是順序的，則在相同的源上重複執行相同的流管道將產生相同的結果;
如果是非順序流，重複執行可能會產生不同的結果。 對於並行流，放寬排序約束有時可以實現更高效的執行。
在流有序時, 但用戶不特別關心該順序的情況下，使用 unordered 明確地對流進行去除有序約束可以改善某些有狀態或終端操作的並行性能。
2.2.3 有狀態（Stateful）操作
- distinct：返回由該流的不同元素組成的流（根據 Object.equals(Object)）；distinct（）使用hashCode（）和equals（）方法來獲取不同的元素。因此，我們的類必須實現hashCode（）和equals（）方法。
Stream<T> distinct();
簡言之：就是去重；下面看下流程解析圖：
舉個栗子：
可以發現，重複的數字會被剔除掉！那麼如果需要對自定義的對象進行過濾，則需要重寫對象的equals方法即可 ！
另外有一個細節可以看到，去重之後還是按照原流中的排序順序輸出的，所以是有序的！
- sorted：返回由該流的元素組成的流，並根據自然順序排序
該接口有兩種形式：無參和有參數，如：
那區別其實就在於：傳入比較器的參數，可以自定義這個比較器，即自定義比較規則。
舉個栗子：
- limit：獲取流中n個元素返回的流
這個很好理解，和mysql的中的limit函數一樣的效果，返回指定個數的元素流。
Stream<T> limit(long maxSize);
流程解析圖如下：
舉個栗子：
- skip：在丟棄流的第一個
n元素之後，返回由該流的其餘元素組成的流。
簡言之：跳過第n個元素，返回其後面的元素流；
Stream<T> skip(long n);
流程解析圖：
舉個栗子：
2.2.4 短路（Short-circuiting）操作
- anyMatch：Stream 中只要有一個元素符合傳入的 predicate，返回 true;
boolean anyMatch(Predicate<? super T> predicate);
舉個栗子：
- allMatch：Stream 中全部元素符合傳入的 predicate，返回 true;
boolean allMatch(Predicate<? super T> predicate);
舉個栗子：
- noneMatch：Stream 中沒有一個元素符合傳入的 predicate，返回 true.
boolean noneMatch(Predicate<? super T> predicate);
舉個栗子：
- findFirst：用於返回滿足條件的第一個元素（但是該元素是封裝在Optional類中）
關於Optional可以點這裏：【Java 8系列】Java開發者的判空利器 -- Optional
Optional<T> findFirst();
舉個栗子：
- findAny：返回流中的任意元素（但是該元素也是封裝在Optional類中）
Optional<T> findAny();
舉個栗子：
通過多次執行，我們會發現，其實findAny會每次按順序返回第一個元素。那這個時候，可能會認爲findAny與findFirst方法是一樣的效果。其實不然，findAny()操作，返回的元素是不確定的，對於同一個列表多次調用findAny()有可能會返回不同的值。使用findAny()是爲了更高效的性能。如果是數據較少，串行地情況下，一般會返回第一個結果，如果是並行的情況，那就不能確保是第一個。
我們接着看下面這個例子：
如此可見，在並行流裏，findAny可就不是隻返回第一個元素啦！
2.2.5 非短路（Unshort-circuiting）操作
- forEach：該方法接收一個Lambda表達式，然後在Stream的每一個元素上執行該表達式
可以理解爲我們平時使用的for循環，但是較於for循環，又略有不同！咱們待會再講。
void forEach(Consumer<? super T> action);
舉個栗子：
那如果我們把 "Jack"用在循環外部用一個變量接收，如下操作：
那麼此時編輯器則會爆紅，
因爲lambda中，使用的外部變量必須是最終的，不可變的，所以如果我們想要對其進行修改，那是不可能的！如果必須這麼使用，可以將外部變量，移至表達式之中使用纔行！
- forEachOrdered：該方法接收一個Lambda表達式，然後按順序在Stream的每一個元素上執行該表達式
void forEachOrdered(Consumer<? super T> action);
該功能其實和forEach是很相似的，也是循環操作！那唯一的區別，就在於forEachOrdered是可以保證循環時元素是按原來的順序逐個循環的！
但是，也不盡其然！因爲有的時候，forEachOrdered也是不能百分百保證有序！例如下面這個例子：
可以看到，在並行流時，由於是多線程處理，其實還是無法保證有序操作的！
- toArray：返回包含此流元素的數組；當有參數時，則使用提供的
generator函數分配返回的數組，以及分區執行或調整大小可能需要的任何其他數組
舉個栗子：
- reduce：方法接收一個函數作爲累加器，數組中的每個值（從左到右）開始縮減，最終計算爲一個值
通過字面意思，可能比較難理解是個什麼意思？下面我們先看一個圖，熟悉一下這個接口的操作流程是怎樣的：
該接口含有3種調用方式：
下面舉幾個栗子，看看具體效果：
（一）.先以1個參數的接口爲例
爲了方便理解，先看下內部的執行效果代碼：
再看下具體栗子：
執行結果都是：
（二）再以2個參數的接口爲例
先看下內部的執行效果代碼：
在看具體栗子：
輸出結果都是：
（三）最後3個參數的接口爲例
這個接口的內部執行效果，其實和2個參數的幾乎一致。那麼第三個參數是啥呢？這是一個combiner組合器；
組合器需要和累加器的返回類型需要進行兼容，combiner組合器的方法主要用在並行操作中
在看具體栗子：
我們再講串行流改成並行流，看下會出現什麼結果：
我們會發現每個結果都是亂序的，並且多執行幾次，都會出現不同的結果。並且第三個參數組合器內的代碼也得到了執行！！
這就是因爲並行時，使用多線程時順序性沒有保障所產生的結果。通過實踐，可以看到：組合器的作用，其實是對參數2中的各個線程，產生的結果進行了再一遍的歸約操作！
並且仔細看第二遍的執行結果：每一組都少了一1個值！！！
所以，對於並行流parallelStream操作，必須慎用！！
- collect：稱爲收集器，是一個終端操作,它接收的參數是將流中的元素累積到彙總結果的各種方式
第一種方式會比較經常使用到，也比較方便使用，現在先看一看裏面常用的一些方法：
| 工廠方法 |
返回類型 |
用於 |
|---|---|---|
| toList |
List<T> |
把流中所有元素收集到List中 |
| 示例:List<Menu> menus=Menu.getMenus.stream().collect(Collectors.toList());
|
||
| toSet |
Set<T> |
把流中所有元素收集到Set中,刪除重複項 |
| 示例:Set<Menu> menus=Menu.getMenus.stream().collect(Collectors.toSet());
|
||
| toCollection |
Collection<T> |
把流中所有元素收集到給定的供應源創建的集合中 |
| 示例:ArrayList<Menu> menus=Menu.getMenus.stream().collect(Collectors.toCollection(ArrayList::new));
|
||
| Counting |
Long |
計算流中元素個數 |
| 示例:Long count=Menu.getMenus.stream().collect(counting);
|
||
| SummingInt |
Integer |
對流中元素的一個整數屬性求和 |
| 示例:Integer count=Menu.getMenus.stream().collect(summingInt(Menu::getCalories));
|
||
| averagingInt |
Double |
計算流中元素integer屬性的平均值 |
| 示例:Double averaging=Menu.getMenus.stream().collect(averagingInt(Menu::getCalories));
|
||
| Joining |
String |
連接流中每個元素的toString方法生成的字符串 |
| 示例:String name=Menu.getMenus.stream().map(Menu::getName).collect(joining(“, ”));
|
||
| maxBy |
Optional<T> |
一個包裹了流中按照給定比較器選出的最大元素的optional |
| 示例:Optional<Menu> fattest=Menu.getMenus.stream().collect(maxBy(Menu::getCalories));
|
||
| minBy |
Optional<T> |
一個包裹了流中按照給定比較器選出的最大元素的optional |
| 示例: Optional<Menu> lessest=Menu.getMenus.stream().collect(minBy(Menu::getCalories));
|
||
| Reducing |
歸約操作產生的類型 |
從一個作爲累加器的初始值開始,利用binaryOperator與流中的元素逐個結合,從而將流歸約爲單個值 |
| 示例:int count=Menu.getMenus.stream().collect(reducing(0,Menu::getCalories,Integer::sum));
|
||
| collectingAndThen |
轉換函數返回的類型 |
包裹另一個轉換器,對其結果應用轉換函數 |
| 示例:Int count=Menu.getMenus.stream().collect(collectingAndThen(toList(),List::size));
|
||
| groupingBy |
Map<K,List<T>> |
根據流中元素的某個值對流中的元素進行分組,並將屬性值做爲結果map的鍵 |
| 示例:Map<Type,List<Menu>> menuType=Menu.getMenus.stream().collect(groupingby(Menu::getType));
|
||
| partitioningBy |
Map<Boolean,List<T>> |
根據流中每個元素應用謂語的結果來對項目進行分區 |
| 示例:Map<Boolean,List<Menu>> menuType=Menu.getMenus.stream().collect(partitioningBy(Menu::isType) |
第二種方式看起來跟reduce的三個入參的方法有點類似，也可以用來實現filter、map等操作！
流程解析圖如下：
舉個栗子：
運行結果：
如果把上述流換成並行流，會得到如下一種結果：
可以看到，根據流內的元素個數n，起了n個線程，同時分別執行了構造器、累加器、合併器內代碼！與reduce的行爲方式基本一致！
- max：根據提供的Comparator返回此流的最大元素
Optional<T> max(Comparator<? super T> comparator);
舉個栗子：
- min：根據提供的Comparator返回此流的最小元素
Optional<T> min(Comparator<? super T> comparator);
舉個栗子：
- count：返回此流中的元素計數
long count();
舉個栗子：
3.總結
此處給正在學習的朋友兩個小提示：
1、對於流的各種操作所屬分類，還不夠熟悉的，可以直接進入方法的源碼接口內，如下，是可以查看到類型說明的：
2、對於並行流stream().parallel()、parallelStream()的使用，須慎重使用！使用前須考慮其不確定因素和無序性，考慮多線程所帶來的複雜性！！
2020年已近年末，再過幾天就要步入新年啦！工作之餘，耗時幾天，終於寫完了這篇博文！分享不易，希望感興趣的朋友，可以留言討論，點贊收藏！