Streams 的背景，以及 Java 8 中的使用詳解

為什么需要 Stream

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

什么是聚合操作

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

客戶每月平均消費(fèi)金額

最昂貴的在售商品

本周完成的有效訂單（排除了無效的）

取十個(gè)數(shù)據(jù)樣本作為首頁推薦

這類的操作。

但在當(dāng)今這個(gè)數(shù)據(jù)大爆炸的時(shí)代，在數(shù)據(jù)來源多樣化、數(shù)據(jù)海量化的今天，很多時(shí)候不得不脫離 RDBMS，或者以底層返回的數(shù)據(jù)為基礎(chǔ)進(jìn)行更上層的數(shù)據(jù)統(tǒng)計(jì)。而 Java 的集合 API 中，僅僅有極少量的輔助型方法，更多的時(shí)候是程序員需要用 Iterator 來遍歷集合，完成相關(guān)的聚合應(yīng)用邏輯。這是一種遠(yuǎn)不夠高效、笨拙的方法。在 Java 7 中，如果要發(fā)現(xiàn) type 為 grocery 的所有交易，然后返回以交易值降序排序好的交易 ID 集合，我們需要這樣寫：

清單 1. Java 7 的排序、取值實(shí)現(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 的排序、取值實(shí)現(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ù)結(jié)構(gòu)并不保存數(shù)據(jù)，它是有關(guān)算法和計(jì)算的，它更像一個(gè)高級(jí)版本的 Iterator。原始版本的 Iterator，用戶只能顯式地一個(gè)一個(gè)遍歷元素并對(duì)其執(zhí)行某些操作；高級(jí)版本的 Stream，用戶只要給出需要對(duì)其包含的元素執(zhí)行什么操作，比如 “過濾掉長度大于 10 的字符串”、“獲取每個(gè)字符串的首字母”等，Stream 會(huì)隱式地在內(nèi)部進(jìn)行遍歷，做出相應(yīng)的數(shù)據(jù)轉(zhuǎn)換。

Stream 就如同一個(gè)迭代器（Iterator），單向，不可往復(fù)，數(shù)據(jù)只能遍歷一次，遍歷過一次后即用盡了，就好比流水從面前流過，一去不復(fù)返。

而和迭代器又不同的是，Stream 可以并行化操作，迭代器只能命令式地、串行化操作。顧名思義，當(dāng)使用串行方式去遍歷時(shí)，每個(gè) item 讀完后再讀下一個(gè) item。而使用并行去遍歷時(shí)，數(shù)據(jù)會(huì)被分成多個(gè)段，其中每一個(gè)都在不同的線程中處理，然后將結(jié)果一起輸出。Stream 的并行操作依賴于 Java7 中引入的 Fork/Join 框架（JSR166y）來拆分任務(wù)和加速處理過程。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 的另外一大特點(diǎn)是，數(shù)據(jù)源本身可以是無限的。

流的構(gòu)成

當(dāng)我們使用一個(gè)流的時(shí)候，通常包括三個(gè)基本步驟：

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

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

有多種方式生成 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()

自己構(gòu)建

java.util.Spliterator

其它

Random.ints()

BitSet.stream()

Pattern.splitAsStream(java.lang.CharSequence)

JarFile.stream()

流的操作類型分為兩種：

Intermediate：一個(gè)流可以后面跟隨零個(gè)或多個(gè) intermediate 操作。其目的主要是打開流，做出某種程度的數(shù)據(jù)映射/過濾，然后返回一個(gè)新的流，交給下一個(gè)操作使用。這類操作都是惰性化的（lazy），就是說，僅僅調(diào)用到這類方法，并沒有真正開始流的遍歷。

Terminal：一個(gè)流只能有一個(gè) terminal 操作，當(dāng)這個(gè)操作執(zhí)行后，流就被使用“光”了，無法再被操作。所以這必定是流的最后一個(gè)操作。Terminal 操作的執(zhí)行，才會(huì)真正開始流的遍歷，并且會(huì)生成一個(gè)結(jié)果，或者一個(gè) side effect。

在對(duì)于一個(gè) Stream 進(jìn)行多次轉(zhuǎn)換操作 (Intermediate 操作)，每次都對(duì) Stream 的每個(gè)元素進(jìn)行轉(zhuǎn)換，而且是執(zhí)行多次，這樣時(shí)間復(fù)雜度就是 N（轉(zhuǎn)換次數(shù)）個(gè) for 循環(huán)里把所有操作都做掉的總和嗎？其實(shí)不是這樣的，轉(zhuǎn)換操作都是 lazy 的，多個(gè)轉(zhuǎn)換操作只會(huì)在 Terminal 操作的時(shí)候融合起來，一次循環(huán)完成。我們可以這樣簡單的理解，Stream 里有個(gè)操作函數(shù)的集合，每次轉(zhuǎn)換操作就是把轉(zhuǎn)換函數(shù)放入這個(gè)集合中，在 Terminal 操作的時(shí)候循環(huán) Stream 對(duì)應(yīng)的集合，然后對(duì)每個(gè)元素執(zhí)行所有的函數(shù)。

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

對(duì)于一個(gè) intermediate 操作，如果它接受的是一個(gè)無限大（infinite/unbounded）的 Stream，但返回一個(gè)有限的新 Stream。

對(duì)于一個(gè) terminal 操作，如果它接受的是一個(gè)無限大的 Stream，但能在有限的時(shí)間計(jì)算出結(jié)果。

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

清單 3. 一個(gè)流操作的示例

int sum = widgets.stream()

.filter(w -> w.getColor() == RED)

?.mapToInt(w -> w.getWeight())

?.sum();

stream() 獲取當(dāng)前小物件的 source，filter 和 mapToInt 為 intermediate 操作，進(jìn)行數(shù)據(jù)篩選和轉(zhuǎn)換，最后一個(gè) sum() 為 terminal 操作，對(duì)符合條件的全部小物件作重量求和。

流的使用詳解

簡單說，對(duì) Stream 的使用就是實(shí)現(xiàn)一個(gè) filter-map-reduce 過程，產(chǎn)生一個(gè)最終結(jié)果，或者導(dǎo)致一個(gè)副作用（side effect）。

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

下面提供最常見的幾種構(gòu)造 Stream 的樣例。

清單 4. 構(gòu)造流的幾種常見方法

// 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();

需要注意的是，對(duì)于基本數(shù)值型，目前有三種對(duì)應(yīng)的包裝類型 Stream：

IntStream、LongStream、DoubleStream。當(dāng)然我們也可以用 Stream<Integer>、Stream<Long> >、Stream<Double>，但是 boxing 和 unboxing 會(huì)很耗時(shí)，所以特別為這三種基本數(shù)值型提供了對(duì)應(yīng)的 Stream。

Java 8 中還沒有提供其它數(shù)值型 Stream，因?yàn)檫@將導(dǎo)致擴(kuò)增的內(nèi)容較多。而常規(guī)的數(shù)值型聚合運(yùn)算可以通過上面三種 Stream 進(jìn)行。

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

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ù)結(jié)構(gòu)

// 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();

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

流的操作

接下來，當(dāng)把一個(gè)數(shù)據(jù)結(jié)構(gòu)包裝成 Stream 后，就要開始對(duì)里面的元素進(jìn)行各類操作了。常見的操作可以歸類如下。

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ù)式語言，對(duì)這個(gè)方法應(yīng)該很了解，它的作用就是把 input Stream 的每一個(gè)元素，映射成 output Stream 的另外一個(gè)元素。

清單 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());

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

從上面例子可以看出，map 生成的是個(gè) 1:1 映射，每個(gè)輸入元素，都按照規(guī)則轉(zhuǎn)換成為另外一個(gè)元素。還有一些場(chǎng)景，是一對(duì)多映射關(guān)系的，這時(shí)需要 flatMap。

清單 9. 一對(duì)多

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 中的層級(jí)結(jié)構(gòu)扁平化，就是將最底層元素抽出來放到一起，最終 output 的新 Stream 里面已經(jīng)沒有 List 了，都是直接的數(shù)字。

filter

filter 對(duì)原始 Stream 進(jìn)行某項(xiàng)測(cè)試，通過測(cè)試的元素被留下來生成一個(gè)新 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 方法接收一個(gè) Lambda 表達(dá)式，然后在 Stream 的每一個(gè)元素上執(zhí)行該表達(dá)式。

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

// 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());

?}

}

對(duì)一個(gè)人員集合遍歷，找出男性并打印姓名?？梢钥闯鰜?，forEach 是為 Lambda 而設(shè)計(jì)的，保持了最緊湊的風(fēng)格。而且 Lambda 表達(dá)式本身是可以重用的，非常方便。當(dāng)需要為多核系統(tǒng)優(yōu)化時(shí)，可以 parallelStream().forEach()，只是此時(shí)原有元素的次序沒法保證，并行的情況下將改變串行時(shí)操作的行為，此時(shí) forEach 本身的實(shí)現(xiàn)不需要調(diào)整，而 Java8 以前的 for 循環(huán) code 可能需要加入額外的多線程邏輯。

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

另外一點(diǎn)需要注意，forEach 是 terminal 操作，因此它執(zhí)行后，Stream 的元素就被“消費(fèi)”掉了，你無法對(duì)一個(gè) Stream 進(jìn)行兩次 terminal 運(yùn)算。下面的代碼是錯(cuò)誤的：

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

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

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

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

findFirst

這是一個(gè) termimal 兼 short-circuiting 操作，它總是返回 Stream 的第一個(gè)元素，或者空。

這里比較重點(diǎn)的是它的返回值類型：Optional。這也是一個(gè)模仿 Scala 語言中的概念，作為一個(gè)容器，它可能含有某值，或者不包含。使用它的目的是盡可能避免 NullPointerException。

清單 14. Optional 的兩個(gè)用例

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;

?};

在更復(fù)雜的 if (xx != null) 的情況中，使用 Optional 代碼的可讀性更好，而且它提供的是編譯時(shí)檢查，能極大的降低 NPE 這種 Runtime Exception 對(duì)程序的影響，或者迫使程序員更早的在編碼階段處理空值問題，而不是留到運(yùn)行時(shí)再發(fā)現(xiàn)和調(diào)試。

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

reduce

這個(gè)方法的主要作用是把 Stream 元素組合起來。它提供一個(gè)起始值（種子），然后依照運(yùn)算規(guī)則（BinaryOperator），和前面 Stream 的第一個(gè)、第二個(gè)、第 n 個(gè)元素組合。從這個(gè)意義上說，字符串拼接、數(shù)值的 sum、min、max、average 都是特殊的 reduce。例如 Stream 的 sum 就相當(dāng)于

Integer sum = integers.reduce(0, (a, b) -> a+b); 或

Integer sum = integers.reduce(0, Integer::sum);

也有沒有起始值的情況，這時(shí)會(huì)把 Stream 的前面兩個(gè)元素組合起來，返回的是 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);

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

limit/skip

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

清單 16. limit 和 skip 對(duì)運(yùn)行次數(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;

?}

}

輸出結(jié)果為：

name1

name2

name3

name4

name5

name6

name7

name8

name9

name10

[name4, name5, name6, name7, name8, name9, name10]

這是一個(gè)有 10，000 個(gè)元素的 Stream，但在 short-circuiting 操作 limit 和 skip 的作用下，管道中 map 操作指定的 getName() 方法的執(zhí)行次數(shù)為 limit 所限定的 10 次，而最終返回結(jié)果在跳過前 3 個(gè)元素后只有后面 7 個(gè)返回。

有一種情況是 limit/skip 無法達(dá)到 short-circuiting 目的的，就是把它們放在 Stream 的排序操作后，原因跟 sorted 這個(gè) intermediate 操作有關(guān)：此時(shí)系統(tǒng)并不知道 Stream 排序后的次序如何，所以 sorted 中的操作看上去就像完全沒有被 limit 或者 skip 一樣。

清單 17. limit 和 skip 對(duì) sorted 后的運(yùn)行次數(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);

上面的示例對(duì)清單 13 做了微調(diào)，首先對(duì) 5 個(gè)元素的 Stream 排序，然后進(jìn)行 limit 操作。輸出結(jié)果為：

name2

name1

name3

name2

name4

name3

name5

name4

[stream.StreamDW$Person@816f27d, stream.StreamDW$Person@87aac27]

即雖然最后的返回元素?cái)?shù)量是 2，但整個(gè)管道中的 sorted 表達(dá)式執(zhí)行次數(shù)沒有像前面例子相應(yīng)減少。

最后有一點(diǎn)需要注意的是，對(duì)一個(gè) parallel 的 Steam 管道來說，如果其元素是有序的，那么 limit 操作的成本會(huì)比較大，因?yàn)樗姆祷貙?duì)象必須是前 n 個(gè)也有一樣次序的元素。取而代之的策略是取消元素間的次序，或者不要用 parallel Stream。

sorted

對(duì) Stream 的排序通過 sorted 進(jìn)行，它比數(shù)組的排序更強(qiáng)之處在于你可以首先對(duì) Stream 進(jìn)行各類 map、filter、limit、skip 甚至 distinct 來減少元素?cái)?shù)量后，再排序，這能幫助程序明顯縮短執(zhí)行時(shí)間。我們對(duì)清單 14 進(jìn)行優(yōu)化：

清單 18. 優(yōu)化：排序前進(jìn)行 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);

結(jié)果會(huì)簡單很多：

name2

name1

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

當(dāng)然，這種優(yōu)化是有 business logic 上的局限性的：即不要求排序后再取值。

min/max/distinct

min 和 max 的功能也可以通過對(duì) Stream 元素先排序，再 findFirst 來實(shí)現(xiàn)，但前者的性能會(huì)更好，為 O(n)，而 sorted 的成本是 O(n log n)。同時(shí)它們作為特殊的 reduce 方法被獨(dú)立出來也是因?yàn)榍笞畲笞钚≈凳呛艹Ｒ姷牟僮鳌?/p>

清單 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 來找出不重復(fù)的單詞。

清單 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 有三個(gè) match 方法，從語義上說：

allMatch：Stream 中全部元素符合傳入的 predicate，返回 true

anyMatch：Stream 中只要有一個(gè)元素符合傳入的 predicate，返回 true

noneMatch：Stream 中沒有一個(gè)元素符合傳入的 predicate，返回 true

它們都不是要遍歷全部元素才能返回結(jié)果。例如 allMatch 只要一個(gè)元素不滿足條件，就 skip 剩下的所有元素，返回 false。對(duì)清單 13 中的 Person 類稍做修改，加入一個(gè) 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);

輸出結(jié)果：

All are adult? false

Any child? true

進(jìn)階：自己生成流

Stream.generate

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

清單 22. 生成 10 個(gè)隨機(jī)整數(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() 還接受自己實(shí)現(xiàn)的 Supplier。例如在構(gòu)造海量測(cè)試數(shù)據(jù)的時(shí)候，用某種自動(dòng)的規(guī)則給每一個(gè)變量賦值；或者依據(jù)公式計(jì)算 Stream 的每個(gè)元素值。這些都是維持狀態(tài)信息的情形。

清單 23. 自實(shí)現(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));

?}

}

輸出結(jié)果：

StormTestUser1, 9

StormTestUser2, 12

StormTestUser3, 88

StormTestUser4, 51

StormTestUser5, 22

StormTestUser6, 28

StormTestUser7, 81

StormTestUser8, 51

StormTestUser9, 4

StormTestUser10, 76

Stream.iterate

iterate 跟 reduce 操作很像，接受一個(gè)種子值，和一個(gè) UnaryOperator（例如 f）。然后種子值成為 Stream 的第一個(gè)元素，f(seed) 為第二個(gè)，f(f(seed)) 第三個(gè)，以此類推。

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

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

輸出結(jié)果：

0 3 6 9 12 15 18 21 24 27

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

進(jìn)階：用 Collectors 來進(jìn)行 reduction 操作

java.util.stream.Collectors 類的主要作用就是輔助進(jìn)行各類有用的 reduction 操作，例如轉(zhuǎn)變輸出為 Collection，把 Stream 元素進(jìn)行歸組。

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 人的信息，然后按照年齡歸組，相同年齡的人放到同一個(gè) 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());

輸出結(jié)果：

Children number: 23

Adult number: 77

在使用條件“年齡小于 18”進(jìn)行分組后可以看到，不到 18 歲的未成年人是一組，成年人是另外一組。partitioningBy 其實(shí)是一種特殊的 groupingBy，它依照條件測(cè)試的是否兩種結(jié)果來構(gòu)造返回的數(shù)據(jù)結(jié)構(gòu)，get(true) 和 get(false) 能即為全部的元素對(duì)象。

結(jié)束語

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

不是數(shù)據(jù)結(jié)構(gòu)

它沒有內(nèi)部存儲(chǔ)，它只是用操作管道從 source（數(shù)據(jù)結(jié)構(gòu)、數(shù)組、generator function、IO channel）抓取數(shù)據(jù)。

它也絕不修改自己所封裝的底層數(shù)據(jù)結(jié)構(gòu)的數(shù)據(jù)。例如 Stream 的 filter 操作會(huì)產(chǎn)生一個(gè)不包含被過濾元素的新 Stream，而不是從 source 刪除那些元素。

所有 Stream 的操作必須以 lambda 表達(dá)式為參數(shù)

不支持索引訪問

你可以請(qǐng)求第一個(gè)元素，但無法請(qǐng)求第二個(gè)，第三個(gè)，或最后一個(gè)。不過請(qǐng)參閱下一項(xiàng)。

很容易生成數(shù)組或者 List

惰性化

很多 Stream 操作是向后延遲的，一直到它弄清楚了最后需要多少數(shù)據(jù)才會(huì)開始。

Intermediate 操作永遠(yuǎn)是惰性化的。

并行能力

當(dāng)一個(gè) Stream 是并行化的，就不需要再寫多線程代碼，所有對(duì)它的操作會(huì)自動(dòng)并行進(jìn)行的。

可以是無限的

集合有固定大小，Stream 則不必。limit(n) 和 findFirst() 這類的 short-circuiting 操作可以對(duì)無限的 Stream 進(jìn)行運(yùn)算并很快完成。

進(jìn)群：可以領(lǐng)取免費(fèi)的架構(gòu)師學(xué)習(xí)資料。

進(jìn)群：了解最新的學(xué)習(xí)動(dòng)態(tài)

進(jìn)群：了解最新的阿里，京東招聘資訊

進(jìn)群：獲取更多的面試資料

1、具有1-5工作經(jīng)驗(yàn)的，面對(duì)目前流行的技術(shù)不知從何下手，需要突破技術(shù)瓶頸的可以加群。

2、在公司待久了，過得很安逸，但跳槽時(shí)面試碰壁。需要在短時(shí)間內(nèi)進(jìn)修、跳槽拿高薪的可以加群。

3、如果沒有工作經(jīng)驗(yàn)，但基礎(chǔ)非常扎實(shí)，對(duì)java工作機(jī)制，常用設(shè)計(jì)思想，常用java開發(fā)框架掌握熟練的，可以加群。

4、覺得自己很牛B，一般需求都能搞定。但是所學(xué)的知識(shí)點(diǎn)沒有系統(tǒng)化，很難在技術(shù)領(lǐng)域繼續(xù)突破的可以加群。

5. 群號(hào)：835638062 點(diǎn)擊鏈接加入群：https://jq.qq.com/?_wv=1027&k=5S3kL3v

6.阿里Java高級(jí)大牛直播講解知識(shí)點(diǎn)，分享知識(shí)，上面五大專題都是各位老師多年工作經(jīng)驗(yàn)的梳理和總結(jié)，帶著大家全面、科學(xué)地建立自己的技術(shù)體系和技術(shù)認(rèn)知！