簡析JAVA8（二）之stream與Lambda

記住了，Stream和InputStream、OutputStream的唯一的關系就是沒有半毛錢關系！

你可以簡單粗暴的了解為是一種更進階的集合疊代器，它讓集合操作更友善、更快捷，邏輯代碼可讀性更高。簡單一句話就是會讓你的代碼顯得更niubility。

而Lambda則是和Stream狼狽為奸，不對，琴瑟和鳴。二者結合使用，會讓你的代碼顯得very niubility。

不信我們先來比較一下：

Java7的排序：

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

Java8的排序：

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

怎麼樣，是不是覺得這幾行代碼至少比上面的貴五毛？

如果Stream的價值隻值這五毛錢的話，那麼它完全沒有必要被創造出來，但他還有更強大的功能，比如：并行處理等，容我後面慢慢說。我們先講幾句不得不講的題外話：

-----------題外話分割線-------------

~~流的操作類型分為兩種：

第一種叫Intermediate：翻譯過來叫中間件。一個流可以後面跟随零個或多個 intermediate 操作。其目的主要是打開流，做出某種程度的資料映射/過濾，然後傳回一個新的流，交給下一個操作使用。這類操作都是惰性化的（lazy），就是說，僅僅調用到這類方法，并沒有真正開始流的周遊。例如：map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered。

第二種叫Terminal：翻譯過來叫最終态。一個流隻能有一個 terminal 操作，當這個操作執行後，流就被使用“光”了，無法再被操作。是以這必定是流的最後一個操作。Terminal 操作的執行，才會真正開始流的周遊，并且會生成一個結果，或者一個 side effect。例如：forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator。

在對于一個 Stream 進行多次轉換操作 (Intermediate 操作)，每次都對 Stream 的每個元素進行轉換，而且是執行多次，這樣時間複雜度就是 N（轉換次數）個 for 循環裡把所有操作都做掉的總和嗎？其實不是這樣的，轉換操作都是 lazy 的，多個轉換操作隻會在 Terminal 操作的時候融合起來，一次循環完成。我們可以這樣簡單的了解，Stream 裡有個操作函數的集合，每次轉換操作就是把轉換函數放入這個集合中，在 Terminal 操作的時候循環 Stream 對應的集合，然後對每個元素執行所有的函數。

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

對于一個 intermediate 操作，如果它接受的是一個無限大（infinite/unbounded）的 Stream，但傳回一個有限的新 Stream。

對于一個 terminal 操作，如果它接受的是一個無限大的 Stream，但能在有限的時間計算出結果。

例如：anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

當操作一個無限大的 Stream，而又希望在有限時間内完成操作，則在管道内擁有一個 short-circuiting 操作是必要非充分條件。

我們來看一個流操作的示例

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

stream() 擷取目前小物件的 source，filter 和 mapToInt 為 intermediate 操作，進行資料篩選和轉換，最後一個 sum() 為 terminal 操作，對符合條件的全部小物件作重量求和。

-----------題外話分割線-------------

好，概念說完，書接上一段，我們這一章還是先把這五毛錢老老實實的說完吧。具體羅列一些使用執行個體，以友善了解記憶：

1、流的構造

// 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();
--------------
//數值流的構造
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);
--------------
針對基本類型專門創造的流：Stream<Integer>、Stream<Long> >、Stream<Double>此處不贅述
           

2, 周遊list集合

　　List<Integer> list = new ArrayList<>();
　　list.add(1);
　　list.add(2);
　　list.add(3);
　　// 直接列印
　　list.forEach(System.out::println);

　　// 取值分别操作
　　list.forEach(i -> {
　　　　System.out.println(i * 3);
　　});

-----------------
//此處摘抄自某論壇：forEach: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：【劃重點】

forEach 是 terminal 操作，是以它執行後，Stream 的元素就被“消費”掉了，你無法對一個 Stream 進行兩次 terminal 運算。下面的代碼是錯誤的：

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

3、map/flatMap

轉換大寫

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

平方數

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

一對多

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

4、filter：顧名思義，按照條件過濾資料，對原始 Stream 進行某項測試，通過測試的元素被留下來生成一個新 Stream

留下偶數

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

把單詞挑出來

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

5、peek【與forEach相似】：對每個元素執行操作并傳回一個新的 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());
           

6、findFirst：傳回 Stream 的第一個元素，或者空

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;
 };
           

這裡要多說一句，代碼中提及到了我們上一章着重介紹過的非空神器【Optional】：

使用 Optional 代碼的可讀性更好，而且它提供的是編譯時檢查，能極大的降低 NPE 這種 Runtime Exception 對程式的影響，或者迫使程式員更早的在編碼階段處理空值問題，而不是留到運作時再發現和調試。

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

7、reduce，這個方法我目前還沒有用到，主要是項目進度緊，及時有用到的情景，也習慣性的想不起來。。。

主要作用是把 Stream 元素組合起來。它提供一個起始值（種子），然後依照運算規則（BinaryOperator），和前面 Stream 的第一個、第二個、第 n 個元素組合。

從這個意義上說，字元串拼接、數值的 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。

// 字元串連接配接，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，請留意這個差別。
*/
           

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

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() 方法的執行次數為 limit 所限定的 10 次，而最終傳回結果在跳過前 3 個元素後隻有後面 7 個傳回。
*/
           

PS:有一種情況是 limit/skip無法達到short-circuiting目的的，就是把它們放在 Stream 的排序操作後，原因跟 sorted 這個 intermediate 操作有關：此時系統并不知道 Stream 排序後的次序如何，是以 sorted 中的操作看上去就像完全沒有被 limit 或者 skip 一樣。

//limit 和 skip 對 sorted 後的運作次數無影響

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

//先對 5 個元素的 Stream 排序，然後進行 limit 操作。輸出結果為：
name2
name1
name3
name2
name4
name3
name5
name4
[[email protected], [email protected]]
           

最後有一點需要注意的是，對一個 parallel 的 Steam 管道來說，如果其元素是有序的，那麼 limit 操作的成本會比較大，因為它的傳回對象必須是前 n 個也有一樣次序的元素。取而代之的政策是取消元素間的次序，或者不要用 parallel Stream。

9、sorted：對 Stream 進行排序，比數組的排序更強之處在于你可以首先對 Stream 進行各類 map、filter、limit、skip 甚至 distinct 來減少元素數量後，再排序，這能幫助程式明顯縮短執行時間：

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
[[email protected], stream.StreamDW$Perso[email protected]]
           

10、min/max/distinct

BufferedReader br = new BufferedReader(new FileReader("c:\\SUService.log"));
int longest = br.lines().
 mapToInt(String::length).
 max().
 getAsInt();
br.close();
System.out.println(longest);
-------------------
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);
           

11、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
/**
allMatch：Stream 中全部元素符合傳入的 predicate，傳回 true
anyMatch：Stream 中隻要有一個元素符合傳入的 predicate，傳回 true
noneMatch：Stream 中沒有一個元素符合傳入的 predicate，傳回 true
它們都不是要周遊全部元素才能傳回結果。例如 allMatch 隻要一個元素不滿足條件，就 skip 剩下的所有元素，傳回 false
*/
           

12、groupingBy/partitioningBy

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
……
           

劃重點：【Stream.generate時管道必須有 limit 這樣的操作來限制 Stream 大小】

//按照未成年人和成年人歸組
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