為什么需要 Stream

Stream 作為 Java 8 的一大亮點音五，它與 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念拿穴。它也不同于 StAX 對 XML 解析的 Stream蛀醉，也不是 Amazon Kinesis 對大數(shù)據(jù)實時處理的 Stream们衙。Java 8 中的 Stream 是對集合（Collection）對象功能的增強，它專注于對集合對象進行各種非常便利鳍刷、高效的聚合操作（aggregate operation）鱼的，或者大批量數(shù)據(jù)操作 (bulk data operation)理盆。Stream API 借助于同樣新出現(xiàn)的 Lambda 表達式，極大的提高編程效率和程序可讀性凑阶。同時它提供串行和并行兩種模式進行匯聚操作猿规，并發(fā)模式能夠充分利用多核處理器的優(yōu)勢，使用 fork/join 并行方式來拆分任務和加速處理過程宙橱。通常編寫并行代碼很難而且容易出錯, 但使用 Stream API 無需編寫一行多線程的代碼姨俩，就可以很方便地寫出高性能的并發(fā)程序。所以說师郑，Java 8 中首次出現(xiàn)的 java.util.stream 是一個函數(shù)式語言+多核時代綜合影響的產(chǎn)物环葵。

什么是聚合操作

在傳統(tǒng)的 J2EE 應用中，Java 代碼經(jīng)常不得不依賴于關系型數(shù)據(jù)庫的聚合操作來完成諸如：

• 客戶每月平均消費金額
• 最昂貴的在售商品
• 本周完成的有效訂單（排除了無效的）
• 取十個數(shù)據(jù)樣本作為首頁推薦

這類的操作宝冕。

但在當今這個數(shù)據(jù)大爆炸的時代张遭，在數(shù)據(jù)來源多樣化、數(shù)據(jù)海量化的今天地梨，很多時候不得不脫離 RDBMS菊卷，或者以底層返回的數(shù)據(jù)為基礎進行更上層的數(shù)據(jù)統(tǒng)計。而 Java 的集合 API 中湿刽，僅僅有極少量的輔助型方法的烁，更多的時候是程序員需要用 Iterator 來遍歷集合褐耳，完成相關的聚合應用邏輯诈闺。這是一種遠不夠高效、笨拙的方法铃芦。在 Java 7 中雅镊，如果要發(fā)現(xiàn) type 為 grocery 的所有交易襟雷，然后返回以交易值降序排序好的交易 ID 集合，我們需要這樣寫：

清單 1. Java 7 的排序仁烹、取值實現(xiàn)

List<Transaction> groceryTransactions = new Arraylist<>();
for(Transaction t: transactions){
 if(t.getType() == Transaction.GROCERY){
 groceryTransactions.add(t);
 }
}
Collections.sort(groceryTransactions, new Comparator(){
 public int compare(Transaction t1, Transaction t2){
 return t2.getValue().compareTo(t1.getValue());
 }
});
List<Integer> transactionIds = new ArrayList<>();
for(Transaction t: groceryTransactions){
 transactionsIds.add(t.getId());
}

而在 Java 8 使用 Stream耸弄，代碼更加簡潔易讀；而且使用并發(fā)模式卓缰，程序執(zhí)行速度更快计呈。

清單 2. Java 8 的排序、取值實現(xiàn)

List<Integer> transactionsIds = transactions.parallelStream().
 filter(t -> t.getType() == Transaction.GROCERY).
 sorted(comparing(Transaction::getValue).reversed()).
 map(Transaction::getId).
 collect(toList());

Stream 總覽

什么是流

Stream 不是集合元素征唬，它不是數(shù)據(jù)結構并不保存數(shù)據(jù)捌显，它是有關算法和計算的，它更像一個高級版本的 Iterator总寒。原始版本的 Iterator扶歪，用戶只能顯式地一個一個遍歷元素并對其執(zhí)行某些操作；高級版本的 Stream摄闸，用戶只要給出需要對其包含的元素執(zhí)行什么操作善镰，比如 “過濾掉長度大于 10 的字符串”、“獲取每個字符串的首字母”等年枕，Stream 會隱式地在內(nèi)部進行遍歷炫欺，做出相應的數(shù)據(jù)轉(zhuǎn)換。

Stream 就如同一個迭代器（Iterator）熏兄，單向竣稽，不可往復，數(shù)據(jù)只能遍歷一次霍弹，遍歷過一次后即用盡了毫别，就好比流水從面前流過，一去不復返典格。

而和迭代器又不同的是岛宦，Stream 可以并行化操作，迭代器只能命令式地耍缴、串行化操作砾肺。顧名思義，當使用串行方式去遍歷時防嗡，每個 item 讀完后再讀下一個 item变汪。而使用并行去遍歷時，數(shù)據(jù)會被分成多個段蚁趁，其中每一個都在不同的線程中處理裙盾，然后將結果一起輸出。Stream 的并行操作依賴于 Java7 中引入的 Fork/Join 框架（JSR166y）來拆分任務和加速處理過程。Java 的并行 API 演變歷程基本如下：

>
\1. 1.0-1.4 中的 java.lang.Thread
\2. 5.0 中的 java.util.concurrent
\02. 6.0 中的 Phasers 等
\10. 7.0 中的 Fork/Join 框架
\1. 8.0 中的 Lambda

Stream 的另外一大特點是番官，數(shù)據(jù)源本身可以是無限的庐完。

流的構成

當我們使用一個流的時候，通常包括三個基本步驟：

獲取一個數(shù)據(jù)源（source）→ 數(shù)據(jù)轉(zhuǎn)換→執(zhí)行操作獲取想要的結果徘熔，每次轉(zhuǎn)換原有 Stream 對象不改變门躯，返回一個新的 Stream 對象（可以有多次轉(zhuǎn)換），這就允許對其操作可以像鏈條一樣排列酷师，變成一個管道讶凉，如下圖所示。

圖 1. 流管道 (Stream Pipeline) 的構成

871373-20170806212158787-89103045.png

有多種方式生成 Stream Source：

• 從 Collection 和數(shù)組

  • Collection.stream()
  • Collection.parallelStream()
  • Arrays.stream(T array) or Stream.of()

  從 BufferedReader

  • java.io.BufferedReader.lines()

• 靜態(tài)工廠

  • java.util.stream.IntStream.range()
  • java.nio.file.Files.walk()

• 自己構建

  • java.util.Spliterator
  • 其它
    • Random.ints()
    • BitSet.stream()
    • Pattern.splitAsStream(java.lang.CharSequence)
    • JarFile.stream()

流的操作類型分為兩種：

• Intermediate：一個流可以后面跟隨零個或多個 intermediate 操作山孔。其目的主要是打開流缀遍，做出某種程度的數(shù)據(jù)映射/過濾，然后返回一個新的流饱须，交給下一個操作使用域醇。這類操作都是惰性化的（lazy），就是說蓉媳，僅僅調(diào)用到這類方法譬挚，并沒有真正開始流的遍歷。
• Terminal：一個流只能有一個 terminal 操作酪呻，當這個操作執(zhí)行后减宣，流就被使用“光”了，無法再被操作玩荠。所以這必定是流的最后一個操作漆腌。Terminal 操作的執(zhí)行，才會真正開始流的遍歷阶冈，并且會生成一個結果闷尿，或者一個 side effect。

在對于一個 Stream 進行多次轉(zhuǎn)換操作 (Intermediate 操作)女坑，每次都對 Stream 的每個元素進行轉(zhuǎn)換填具，而且是執(zhí)行多次，這樣時間復雜度就是 N（轉(zhuǎn)換次數(shù)）個 for 循環(huán)里把所有操作都做掉的總和嗎匆骗？其實不是這樣的劳景，轉(zhuǎn)換操作都是 lazy 的，多個轉(zhuǎn)換操作只會在 Terminal 操作的時候融合起來碉就，一次循環(huán)完成盟广。我們可以這樣簡單的理解，Stream 里有個操作函數(shù)的集合瓮钥，每次轉(zhuǎn)換操作就是把轉(zhuǎn)換函數(shù)放入這個集合中筋量，在 Terminal 操作的時候循環(huán) Stream 對應的集合烹吵，然后對每個元素執(zhí)行所有的函數(shù)。

還有一種操作被稱為 short-circuiting毛甲。用以指：

• 對于一個intermediate 操作年叮，如果它接受的是一個無限大（infinite/unbounded）的Stream具被，但返回一個有限的新Stream玻募。
• 對于一個 terminal 操作，如果它接受的是一個無限大的 Stream一姿，但能在有限的時間計算出結果七咧。

當操作一個無限大的 Stream，而又希望在有限時間內(nèi)完成操作叮叹，則在管道內(nèi)擁有一個 short-circuiting 操作是必要非充分條件艾栋。

清單 3. 一個流操作的示例

int sum = widgets.stream()
.filter(w -> w.getColor() == RED)
 .mapToInt(w -> w.getWeight())
 .sum();

stream() 獲取當前小物件的 source，filter 和 mapToInt 為 intermediate 操作蛉顽，進行數(shù)據(jù)篩選和轉(zhuǎn)換蝗砾，最后一個 sum() 為 terminal 操作，對符合條件的全部小物件作重量求和携冤。

流的使用詳解

簡單說悼粮，對 Stream 的使用就是實現(xiàn)一個 filter-map-reduce 過程，產(chǎn)生一個最終結果曾棕，或者導致一個副作用（side effect）扣猫。

流的構造與轉(zhuǎn)換

下面提供最常見的幾種構造 Stream 的樣例。

清單 4. 構造流的幾種常見方法

// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();

需要注意的是翘地，對于基本數(shù)值型申尤，目前有三種對應的包裝類型 Stream：

IntStream、LongStream衙耕、DoubleStream昧穿。當然我們也可以用 Stream<Integer>、Stream<Long> >橙喘、Stream<Double>粤咪，但是 boxing 和 unboxing 會很耗時，所以特別為這三種基本數(shù)值型提供了對應的Stream渴杆。
Java 8 中還沒有提供其它數(shù)值型 Stream寥枝，因為這將導致擴增的內(nèi)容較多。而常規(guī)的數(shù)值型聚合運算可以通過上面三種 Stream 進行磁奖。

清單 5. 數(shù)值流的構造

IntStream.of(new int[]{1, 2, 3}).forEach(System.out::println);
IntStream.range(1, 3).forEach(System.out::println);
IntStream.rangeClosed(1, 3).forEach(System.out::println);

清單 6. 流轉(zhuǎn)換為其它數(shù)據(jù)結構

// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();

一個 Stream 只可以使用一次囊拜，上面的代碼為了簡潔而重復使用了數(shù)次。

流的操作

接下來比搭，當把一個數(shù)據(jù)結構包裝成 Stream 后冠跷，就要開始對里面的元素進行各類操作了。常見的操作可以歸類如下。

• Intermediate
  • map (mapToInt, flatMap 等)蜜托、 filter抄囚、 distinct、 sorted橄务、 peek幔托、 limit、 skip蜂挪、 parallel重挑、 sequential、 unordered
• Terminal
  • forEach棠涮、 forEachOrdered谬哀、 toArray、 reduce严肪、 collect史煎、 min、 max驳糯、 count篇梭、 anyMatch、 allMatch结窘、 noneMatch很洋、 findFirst、 findAny隧枫、 iterator
• Short-circuiting
  • anyMatch喉磁、 allMatch、 noneMatch官脓、 findFirst协怒、 findAny、 limit

我們下面看一下 Stream 的比較典型用法卑笨。

map/flatMap

我們先來看 map孕暇。如果你熟悉 scala 這類函數(shù)式語言，對這個方法應該很了解赤兴，它的作用就是把 inputStream的每一個元素妖滔，映射成 outputStream 的另外一個元素。

清單 7. 轉(zhuǎn)換大寫

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

這段代碼把所有的單詞轉(zhuǎn)換為大寫桶良。

清單 8. 平方數(shù)

List<Integer> nums = Arrays.asList(1, 2, 3, 4);
List<Integer> squareNums = nums.stream().
map(n -> n * n).
collect(Collectors.toList());

這段代碼生成一個整數(shù) list 的平方數(shù) {1, 4, 9, 16}座舍。

從上面例子可以看出，map 生成的是個 1:1 映射陨帆，每個輸入元素曲秉，都按照規(guī)則轉(zhuǎn)換成為另外一個元素采蚀。還有一些場景，是一對多映射關系的承二，這時需要 flatMap榆鼠。

清單 9. 一對多

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

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

filter

filter 對原始 Stream 進行某項測試读虏，通過測試的元素被留下來生成一個新 Stream责静。

清單 10. 留下偶數(shù)

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

經(jīng)過條件“被 2 整除”的 filter袁滥，剩下的數(shù)字為 {2, 4, 6}盖桥。

清單 11. 把單詞挑出來

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

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

forEach

forEach 方法接收一個 Lambda 表達式，然后在 Stream 的每一個元素上執(zhí)行該表達式嵌赠。

清單 12. 打印姓名（forEach 和 pre-java8 的對比）

// Java 8
roster.stream()
 .filter(p -> p.getGender() == Person.Sex.MALE)
 .forEach(p -> System.out.println(p.getName()));
// Pre-Java 8
for (Person p : roster) {
 if (p.getGender() == Person.Sex.MALE) {
 System.out.println(p.getName());
 }
}

對一個人員集合遍歷塑荒，找出男性并打印姓名〗Γ可以看出來齿税，forEach 是為 Lambda 而設計的，保持了最緊湊的風格炊豪。而且 Lambda 表達式本身是可以重用的凌箕，非常方便。當需要為多核系統(tǒng)優(yōu)化時词渤，可以 parallelStream().forEach()牵舱，只是此時原有元素的次序沒法保證，并行的情況下將改變串行時操作的行為缺虐，此時 forEach 本身的實現(xiàn)不需要調(diào)整芜壁，而 Java8 以前的 for 循環(huán) code 可能需要加入額外的多線程邏輯。

但一般認為高氮，forEach 和常規(guī) for 循環(huán)的差異不涉及到性能慧妄，它們僅僅是函數(shù)式風格與傳統(tǒng) Java 風格的差別。

另外一點需要注意剪芍，forEach 是 terminal 操作塞淹，因此它執(zhí)行后，Stream 的元素就被“消費”掉了紊浩，你無法對一個 Stream 進行兩次 terminal 運算窖铡。下面的代碼是錯誤的：

stream.forEach(element -> doOneThing(element));
stream.forEach(element -> doAnotherThing(element));

相反疗锐，具有相似功能的 intermediate 操作 peek 可以達到上述目的。如下是出現(xiàn)在該 api javadoc 上的一個示例费彼。

清單 13. peek 對每個元素執(zhí)行操作并返回一個新的 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 之類的關鍵字提前結束循環(huán)。

findFirst

這是一個 termimal 兼 short-circuiting 操作箍铲，它總是返回 Stream 的第一個元素雇卷，或者空。

這里比較重點的是它的返回值類型：Optional颠猴。這也是一個模仿 Scala 語言中的概念关划，作為一個容器，它可能含有某值翘瓮，或者不包含贮折。使用它的目的是盡可能避免 NullPointerException。

清單 14. 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 對程序的影響呵扛，或者迫使程序員更早的在編碼階段處理空值問題每庆，而不是留到運行時再發(fā)現(xiàn)和調(diào)試。

Stream 中的 findAny今穿、max/min缤灵、reduce 等方法等返回 Optional 值。還有例如 IntStream.average() 返回 OptionalDouble 等等蓝晒。

reduce

這個方法的主要作用是把 Stream 元素組合起來腮出。它提供一個起始值（種子），然后依照運算規(guī)則（BinaryOperator）拔创，和前面 Stream 的第一個利诺、第二個、第 n 個元素組合剩燥。從這個意義上說慢逾，字符串拼接、數(shù)值的 sum灭红、min侣滩、max、average 都是特殊的 reduce变擒。例如 Stream 的 sum 就相當于Integer sum = integers.reduce(0, (a, b) -> a+b); 或Integer sum = integers.reduce(0, Integer::sum);

也有沒有起始值的情況君珠，這時會把 Stream 的前面兩個元素組合起來，返回的是 Optional娇斑。

清單 15. 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()浸颓，第一個參數(shù)（空白字符）即為起始值物臂，第二個參數(shù)（String::concat）為 BinaryOperator。這類有起始值的 reduce() 都返回具體的對象产上。而對于第四個示例沒有起始值的 reduce()棵磷，由于可能沒有足夠的元素，返回的是 Optional晋涣，請留意這個區(qū)別仪媒。

limit/skip

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

清單 16. limit 和 skip 對運行次數(shù)的影響

public void testLimitAndSkip() {
 List<Person> persons = new ArrayList();
 for (int i = 1; i <= 10000; i++) {
 Person person = new Person(i, "name" + i);
 persons.add(person);
 }
List<String> personList2 = persons.stream().
map(Person::getName).limit(10).skip(3).collect(Collectors.toList());
 System.out.println(personList2);
}
private class Person {
 public int no;
 private String name;
 public Person (int no, String name) {
 this.no = no;
 this.name = name;
 }
 public String getName() {
 System.out.println(name);
 return name;
 }
}

輸出結果為：

name1
name2
name3
name4
name5
name6
name7
name8
name9
name10
[name4, name5, name6, name7, name8, name9, name10]

這是一個有 10规丽，000 個元素的 Stream蒲牧，但在 short-circuiting 操作 limit 和 skip 的作用下撇贺，管道中 map 操作指定的 getName() 方法的執(zhí)行次數(shù)為 limit 所限定的 10 次，而最終返回結果在跳過前 3 個元素后只有后面 7 個返回冰抢。
有一種情況是 limit/skip 無法達到 short-circuiting 目的的松嘶，就是把它們放在 Stream 的排序操作后，原因跟 sorted 這個 intermediate 操作有關：此時系統(tǒng)并不知道 Stream 排序后的次序如何挎扰，所以 sorted 中的操作看上去就像完全沒有被 limit 或者 skip 一樣翠订。

清單 17. limit 和 skip 對 sorted 后的運行次數(shù)無影響

List<Person> persons = new ArrayList();
 for (int i = 1; i <= 5; i++) {
 Person person = new Person(i, "name" + i);
 persons.add(person);
 }
List<Person> personList2 = persons.stream().sorted((p1, p2) -> 
p1.getName().compareTo(p2.getName())).limit(2).collect(Collectors.toList());
System.out.println(personList2);

上面的示例對清單 13 做了微調(diào)，首先對 5 個元素的 Stream 排序遵倦，然后進行 limit 操作尽超。輸出結果為：

name2
name1
name3
name2
name4
name3
name5
name4
[stream.StreamDW$Person@816f27d, stream.StreamDW$Person@87aac27]

即雖然最后的返回元素數(shù)量是 2，但整個管道中的 sorted 表達式執(zhí)行次數(shù)沒有像前面例子相應減少梧躺。

最后有一點需要注意的是似谁，對一個 parallel 的 Steam 管道來說，如果其元素是有序的掠哥，那么 limit 操作的成本會比較大巩踏，因為它的返回對象必須是前 n 個也有一樣次序的元素。取而代之的策略是取消元素間的次序续搀，或者不要用 parallel Stream塞琼。

sorted

對 Stream 的排序通過 sorted 進行，它比數(shù)組的排序更強之處在于你可以首先對 Stream 進行各類 map禁舷、filter彪杉、limit毅往、skip 甚至 distinct 來減少元素數(shù)量后，再排序派近，這能幫助程序明顯縮短執(zhí)行時間煞抬。我們對清單 14 進行優(yōu)化：

清單 18. 優(yōu)化：排序前進行 limit 和 skip

List<Person> persons = new ArrayList();
 for (int i = 1; i <= 5; i++) {
 Person person = new Person(i, "name" + i);
 persons.add(person);
 }
List<Person> personList2 = persons.stream().limit(2).sorted((p1, p2) -> p1.getName().compareTo(p2.getName())).collect(Collectors.toList());
System.out.println(personList2);

結果會簡單很多：

name2
name1
[stream.StreamDW$Person@6ce253f1, stream.StreamDW$Person@53d8d10a]

當然，這種優(yōu)化是有 business logic 上的局限性的：即不要求排序后再取值构哺。
min/max/distinct

min 和 max 的功能也可以通過對 Stream 元素先排序革答，再 findFirst 來實現(xiàn)，但前者的性能會更好曙强，為 O(n)残拐，而 sorted 的成本是 O(n log n)。同時它們作為特殊的 reduce 方法被獨立出來也是因為求最大最小值是很常見的操作碟嘴。

清單 19. 找出最長一行的長度

BufferedReader br = new BufferedReader(new FileReader("c:\\SUService.log"));
int longest = br.lines().
 mapToInt(String::length).
 max().
 getAsInt();
br.close();
System.out.println(longest);

下面的例子則使用 distinct 來找出不重復的單詞溪食。

清單 20. 找出全文的單詞，轉(zhuǎn)小寫娜扇，并排序

List<String> words = br.lines().
 flatMap(line -> Stream.of(line.split(" "))).
 filter(word -> word.length() > 0).
 map(String::toLowerCase).
 distinct().
 sorted().
 collect(Collectors.toList());
br.close();
System.out.println(words);

Match

Stream 有三個 match 方法错沃，從語義上說：

• allMatch：Stream 中全部元素符合傳入的 predicate，返回 true
• anyMatch：Stream 中只要有一個元素符合傳入的 predicate雀瓢，返回 true
• noneMatch：Stream 中沒有一個元素符合傳入的 predicate枢析，返回 true
  它們都不是要遍歷全部元素才能返回結果。例如 allMatch 只要一個元素不滿足條件刃麸，就 skip 剩下的所有元素悉患，返回 false喇澡。對清單 13 中的 Person 類稍做修改，加入一個 age 屬性和 getAge 方法。

清單 21. 使用 Match

List<Person> 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);

輸出結果：

All are adult? false
Any child? true

進階：自己生成流

Stream.generate

通過實現(xiàn) Supplier 接口啡直，你可以自己來控制流的生成欠橘。這種情形通常用于隨機數(shù)涛酗、常量的 Stream欺矫，或者需要前后元素間維持著某種狀態(tài)信息的 Stream。把 Supplier 實例傳遞給 Stream.generate() 生成的 Stream篮奄，默認是串行（相對 parallel 而言）但無序的（相對 ordered 而言）捆愁。由于它是無限的，在管道中宦搬，必須利用 limit 之類的操作限制 Stream 大小牙瓢。

清單 22. 生成 10 個隨機整數(shù)

Random seed = new Random();
Supplier<Integer> random = seed::nextInt;
Stream.generate(random).limit(10).forEach(System.out::println);
//Another way
IntStream.generate(() -> (int) (System.nanoTime() % 100)).
limit(10).forEach(System.out::println);

Stream.generate() 還接受自己實現(xiàn)的 Supplier。例如在構造海量測試數(shù)據(jù)的時候间校，用某種自動的規(guī)則給每一個變量賦值矾克；或者依據(jù)公式計算 Stream 的每個元素值。這些都是維持狀態(tài)信息的情形憔足。

清單 23. 自實現(xiàn) Supplier

Stream.generate(new PersonSupplier()).
limit(10).
forEach(p -> System.out.println(p.getName() + ", " + p.getAge()));
private class PersonSupplier implements Supplier<Person> {
 private int index = 0;
 private Random random = new Random();
 @Override
 public Person get() {
 return new Person(index++, "StormTestUser" + index, random.nextInt(100));
 }
}

輸出結果：

StormTestUser1, 9
StormTestUser2, 12
StormTestUser3, 88
StormTestUser4, 51
StormTestUser5, 22
StormTestUser6, 28
StormTestUser7, 81
StormTestUser8, 51
StormTestUser9, 4
StormTestUser10, 76

iterate 跟 reduce 操作很像胁附，接受一個種子值酒繁，和一個 UnaryOperator（例如 f）。然后種子值成為 Stream 的第一個元素控妻，f(seed) 為第二個州袒，f(f(seed)) 第三個，以此類推弓候。

清單 24. 生成一個等差數(shù)列

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 大小。
進階：用 Collectors 來進行 reduction 操作
java.util.stream.Collectors 類的主要作用就是輔助進行各類有用的 reduction 操作菇存，例如轉(zhuǎn)變輸出為 Collection夸研，把 Stream 元素進行歸組。
groupingBy/partitioningBy

清單 25. 按照年齡歸組

Map<Integer, List<Person>> personGroups = Stream.generate(new PersonSupplier()).
 limit(100).
 collect(Collectors.groupingBy(Person::getAge));
Iterator it = personGroups.entrySet().iterator();
while (it.hasNext()) {
 Map.Entry<Integer, List<Person>> 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
……

清單 26. 按照未成年人和成年人歸組

Map<Boolean, List<Person>> 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茶敏，它依照條件測試的是否兩種結果來構造返回的數(shù)據(jù)結構，get(true) 和 get(false) 能即為全部的元素對象蒸播。

結束語

總之睡榆，Stream 的特性可以歸納為：

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