Lambda表達(dá)式

Ocean 發(fā)布于2019-08-15 12:18 / 475人閱讀

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

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ù)源本身可以是無限的。

map/flatMap
清單 1. 轉(zhuǎn)換大寫

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

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

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

filter
filter 對(duì)原始 Stream 進(jìn)行某項(xiàng)測(cè)試，通過測(cè)試的元素被留下來生成一個(gè)新 Stream。
清單 3. 留下偶數(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}。
清單 4. 把單詞挑出來

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

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

forEach
另外一點(diǎn)需要注意，forEach 是 terminal 操作，因此它執(zhí)行后，Stream 的元素就被“消費(fèi)”掉了，你無法對(duì)一個(gè) Stream 進(jìn)行兩次 terminal 運(yùn)算。下面的代碼是錯(cuò)誤的：
1
2
stream.forEach(element -> doOneThing(element));
stream.forEach(element -> doAnotherThing(element));
相反，具有相似功能的 intermediate 操作 peek 可以達(dá)到上述目的。如下是出現(xiàn)在該 api javadoc 上的一個(gè)示例。
清單 5. 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
清單 6. 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
清單 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);
上面代碼例如第一個(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 的方法改名而來）。

Match
Stream 有三個(gè) match 方法，從語義上說：
allMatch：Stream 中全部元素符合傳入的 predicate，返回 true
anyMatch：Stream 中只要有一個(gè)元素符合傳入的 predicate，返回 true
noneMatch：Stream 中沒有一個(gè)元素符合傳入的 predicate，返回 true
它們都不是要遍歷全部元素才能返回結(jié)果。例如 allMatch 只要一個(gè)元素不滿足條件，就 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);

輸出結(jié)果：
1
2
All are adult? false
Any child? true

進(jìn)階：自己生成流
Stream.iterate
iterate 跟 reduce 操作很像，接受一個(gè)種子值，和一個(gè) UnaryOperator（例如 f）。然后種子值成為 Stream 的第一個(gè)元素，f(seed) 為第二個(gè)，f(f(seed)) 第三個(gè)，以此類推。
清單 8. 生成一個(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 大小。

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

輸出結(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ì)象。

總之，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)算并很快完成。

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