摘要：就如同一個迭代器，單向，不可往復，數據只能遍歷一次，遍歷過一次后即用盡了，就好比流水從面前流過，一去不復返。而和迭代器又不同的是，可以并行化操作，迭代器只能命令式地串行化操作。

Stream 就如同一個迭代器（Iterator），單向，不可往復，數據只能遍歷一次，遍歷過一次后即用盡了，就好比流水從面前流過，一去不復返。
而和迭代器又不同的是，Stream 可以并行化操作，迭代器只能命令式地、串行化操作。顧名思義，當使用串行方式去遍歷時，每個 item 讀完后再讀下一個 item。而使用并行去遍歷時，數據會被分成多個段，其中每一個都在不同的線程中處理，然后將結果一起輸出。Stream 的并行操作依賴于 Java7 中引入的 Fork/Join 框架（JSR166y）來拆分任務和加速處理過程。Java 的并行 API 演變歷程基本如下：
1.0-1.4 中的 java.lang.Thread
5.0 中的 java.util.concurrent
6.0 中的 Phasers 等
7.0 中的 Fork/Join 框架
8.0 中的 Lambda
Stream 的另外一大特點是，數據源本身可以是無限的。

map/flatMap
清單 1. 轉換大寫

List output = wordList.stream().
map(String::toUpperCase).
collect(Collectors.toList());

從上面例子可以看出，map 生成的是個 1:1 映射，每個輸入元素，都按照規則轉換成為另外一個元素。還有一些場景，是一對多映射關系的，這時需要 flatMap。
清單 2. 一對多

Stream> inputStream = Stream.of(
 Arrays.asList(1),
 Arrays.asList(2, 3),
 Arrays.asList(4, 5, 6)
 );
Stream outputStream = inputStream.
flatMap((childList) -> childList.stream());

flatMap 把 input Stream 中的層級結構扁平化，就是將最底層元素抽出來放到一起，最終 output 的新 Stream 里面已經沒有 List 了，都是直接的數字。

filter
filter 對原始 Stream 進行某項測試，通過測試的元素被留下來生成一個新 Stream。
清單 3. 留下偶數

Integer[] sixNums = {1, 2, 3, 4, 5, 6};
Integer[] evens =
Stream.of(sixNums).filter(n -> n%2 == 0).toArray(Integer[]::new);

經過條件“被 2 整除”的 filter，剩下的數字為 {2, 4, 6}。
清單 4. 把單詞挑出來

List output = reader.lines().
 flatMap(line -> Stream.of(line.split(REGEXP))).
 filter(word -> word.length() > 0).
 collect(Collectors.toList());

這段代碼首先把每行的單詞用 flatMap 整理到新的 Stream，然后保留長度不為 0 的，就是整篇文章中的全部單詞了。

forEach
另外一點需要注意，forEach 是 terminal 操作，因此它執行后，Stream 的元素就被“消費”掉了，你無法對一個 Stream 進行兩次 terminal 運算。下面的代碼是錯誤的：
1
2
stream.forEach(element -> doOneThing(element));
stream.forEach(element -> doAnotherThing(element));
相反，具有相似功能的 intermediate 操作 peek 可以達到上述目的。如下是出現在該 api javadoc 上的一個示例。
清單 5. peek 對每個元素執行操作并返回一個新的 Stream

Stream.of("one", "two", "three", "four")
 .filter(e -> e.length() > 3)
 .peek(e -> System.out.println("Filtered value: " + e))
 .map(String::toUpperCase)
 .peek(e -> System.out.println("Mapped value: " + e))
 .collect(Collectors.toList());

forEach 不能修改自己包含的本地變量值，也不能用 break/return 之類的關鍵字提前結束循環。

findFirst
清單 6. Optional 的兩個用例

String strA = " abcd ", strB = null;
print(strA);
print("");
print(strB);
getLength(strA);
getLength("");
getLength(strB);
public static void print(String text) {
 // Java 8
 Optional.ofNullable(text).ifPresent(System.out::println);
 // Pre-Java 8
 if (text != null) {
 System.out.println(text);
 }
 }
public static int getLength(String text) {
 // Java 8
return Optional.ofNullable(text).map(String::length).orElse(-1);
 // Pre-Java 8
// return if (text != null) ? text.length() : -1;
 };

在更復雜的 if (xx != null) 的情況中，使用 Optional 代碼的可讀性更好，而且它提供的是編譯時檢查，能極大的降低 NPE 這種 Runtime Exception 對程序的影響，或者迫使程序員更早的在編碼階段處理空值問題，而不是留到運行時再發現和調試。
Stream 中的 findAny、max/min、reduce 等方法等返回 Optional 值。還有例如 IntStream.average() 返回 OptionalDouble 等等。

reduce
清單 7. reduce 的用例
// 字符串連接，concat = "ABCD"

String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); 

// 求最小值，minValue = -3.0

double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min); 

// 求和，sumValue = 10, 有起始值

int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);

// 求和，sumValue = 10, 無起始值

sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();

// 過濾，字符串連接，concat = "ace"

concat = Stream.of("a", "B", "c", "D", "e", "F").
 filter(x -> x.compareTo("Z") > 0).

reduce("", String::concat);
上面代碼例如第一個示例的 reduce()，第一個參數（空白字符）即為起始值，第二個參數（String::concat）為 BinaryOperator。這類有起始值的 reduce() 都返回具體的對象。而對于第四個示例沒有起始值的 reduce()，由于可能沒有足夠的元素，返回的是 Optional，請留意這個區別。

limit/skip
limit 返回 Stream 的前面 n 個元素；skip 則是扔掉前 n 個元素（它是由一個叫 subStream 的方法改名而來）。

Match
Stream 有三個 match 方法，從語義上說：
allMatch：Stream 中全部元素符合傳入的 predicate，返回 true
anyMatch：Stream 中只要有一個元素符合傳入的 predicate，返回 true
noneMatch：Stream 中沒有一個元素符合傳入的 predicate，返回 true
它們都不是要遍歷全部元素才能返回結果。例如 allMatch 只要一個元素不滿足條件，就 skip 剩下的所有元素，返回 false。
使用 Match

List persons = new ArrayList();
persons.add(new Person(1, "name" + 1, 10));
persons.add(new Person(2, "name" + 2, 21));
persons.add(new Person(3, "name" + 3, 34));
persons.add(new Person(4, "name" + 4, 6));
persons.add(new Person(5, "name" + 5, 55));
boolean isAllAdult = persons.stream().
 allMatch(p -> p.getAge() > 18);
System.out.println("All are adult? " + isAllAdult);
boolean isThereAnyChild = persons.stream().
 anyMatch(p -> p.getAge() < 12);
System.out.println("Any child? " + isThereAnyChild);

輸出結果：
1
2
All are adult? false
Any child? true

進階：自己生成流
Stream.iterate
iterate 跟 reduce 操作很像，接受一個種子值，和一個 UnaryOperator（例如 f）。然后種子值成為 Stream 的第一個元素，f(seed) 為第二個，f(f(seed)) 第三個，以此類推。
清單 8. 生成一個等差數列

Stream.iterate(0, n -> n + 3).limit(10). forEach(x -> System.out.print(x + " "));.

輸出結果：

0 3 6 9 12 15 18 21 24 27

與 Stream.generate 相仿，在 iterate 時候管道必須有 limit 這樣的操作來限制 Stream 大小。

groupingBy/partitioningBy
清單 9. 按照年齡歸組

Map> personGroups = Stream.generate(new PersonSupplier()).
 limit(100).
 collect(Collectors.groupingBy(Person::getAge));
Iterator it = personGroups.entrySet().iterator();
while (it.hasNext()) {
 Map.Entry> persons = (Map.Entry) it.next();
 System.out.println("Age " + persons.getKey() + " = " + persons.getValue().size());
}

上面的 code，首先生成 100 人的信息，然后按照年齡歸組，相同年齡的人放到同一個 list 中，可以看到如下的輸出：
Age 0 = 2
Age 1 = 2
Age 5 = 2
Age 8 = 1
Age 9 = 1
Age 11 = 2
……
清單 10. 按照未成年人和成年人歸組

Map> children = Stream.generate(new PersonSupplier()).
 limit(100).
 collect(Collectors.partitioningBy(p -> p.getAge() < 18));
System.out.println("Children number: " + children.get(true).size());
System.out.println("Adult number: " + children.get(false).size());

輸出結果：
Children number: 23
Adult number: 77
在使用條件“年齡小于 18”進行分組后可以看到，不到 18 歲的未成年人是一組，成年人是另外一組。partitioningBy 其實是一種特殊的 groupingBy，它依照條件測試的是否兩種結果來構造返回的數據結構，get(true) 和 get(false) 能即為全部的元素對象。

總之，Stream 的特性可以歸納為：
不是數據結構
它沒有內部存儲，它只是用操作管道從 source（數據結構、數組、generator function、IO channel）抓取數據。
它也絕不修改自己所封裝的底層數據結構的數據。例如 Stream 的 filter 操作會產生一個不包含被過濾元素的新 Stream，而不是從 source 刪除那些元素。
所有 Stream 的操作必須以 lambda 表達式為參數
不支持索引訪問
你可以請求第一個元素，但無法請求第二個，第三個，或最后一個。不過請參閱下一項。
很容易生成數組或者 List
惰性化
很多 Stream 操作是向后延遲的，一直到它弄清楚了最后需要多少數據才會開始。
Intermediate 操作永遠是惰性化的。
并行能力
當一個 Stream 是并行化的，就不需要再寫多線程代碼，所有對它的操作會自動并行進行的。
可以是無限的
集合有固定大小，Stream 則不必。limit(n) 和 findFirst() 這類的 short-circuiting 操作可以對無限的 Stream 進行運算并很快完成。

參考鏈接：https://www.ibm.com/developer...