Java8之Stream用法

原文:https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/index.html   博主只是對其進行總結

一 什么是流？

      Stream 不是集合元素，它不是數據結構並不保存數據，它是有關算法和計算的，它更像一個高級版本的 Iterator。原始版本的 Iterator，用戶只能顯式地一個一個遍歷元素並對其執行某些操作；高級版本的 Stream，用戶只要給出需要對其包含的元素執行什么操作，比如 “過濾掉長度大於 10 的字符串”、“獲取每個字符串的首字母”等，Stream 會隱式地在內部進行遍歷，做出相應的數據轉換。

     Stream 就如同一個迭代器（Iterator），單向，不可往復，數據只能遍歷一次，遍歷過一次后即用盡了，就好比流水從面前流過，一去不復返。而和迭代器又不同的是，Stream 可以並行化操作，迭代器只能命令式地、串行化操作。顧名思義，當使用串行方式去遍歷時，每個 item 讀完后再讀下一個 item。而使用並行去遍歷時，數據會被分成多個段，其中每一個都在不同的線程中處理，然后將結果一起輸出。

 

二   流的構成與創建

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

獲取一個數據源（source）→ 數據轉換→執行操作獲取想要的結果，每次轉換原有 Stream 對象不改變，返回一個新的 Stream 對象（可以有多次轉換），這就允許對其操作可以像鏈條一樣排列，變成一個管道。

創建方式:

2.1 從 Collection 和數組

Collection.stream()

Collection.parallelStream()

Arrays.stream(T array) or Stream.of(T array)

2.2 從 BufferedReader

java.io.BufferedReader.lines()

2.3 靜態工廠

java.util.stream.IntStream.range()

java.nio.file.Files.walk()

2.4 自己構建

java.util.Spliterator

2.5 其它

Random.ints()

BitSet.stream()

Pattern.splitAsStream(java.lang.CharSequence)

JarFile.stream()

 

三 流的操作

3.1 Intermediate  & Termediate

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

Terminal：一個流只能有一個 terminal 操作，當這個操作執行后，流就被使用“光”了，無法再被操作。所以這必定是流的最后一個操作。Terminal 操作的執行，才會真正開始流的遍歷，並且會生成一個結果，或者一個 side effect。

理解實質:

      在對於一個 Stream 進行多次轉換操作 (Intermediate 操作)，每次都對 Stream 的每個元素進行轉換，而且是執行多次，這樣時間復雜度就是 N（轉換次數）個 for 循環里把所有操作都做掉的總和嗎？不是這樣的，轉換操作都是 lazy 的，多個轉換操作只會在 Terminal 操作的時候融合起來，一次循環完成。這樣簡單的理解，Stream 里有個操作函數的集合，每次轉換操作就是把轉換函數放入這個集合中，在 Terminal 操作的時候循環 Stream 對應的集合，然后對每個元素執行所有的函數。

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

• 對於一個 intermediate 操作，如果它接受的是一個無限大（infinite/unbounded）的 Stream，但返回一個有限的新 Stream。
• 對於一個 terminal 操作，如果它接受的是一個無限大的 Stream，但能在有限的時間計算出結果。

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

 

3.2 構造實例:

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

需要注意的是，對於基本數值型，目前有三種對應的包裝類型 Stream：

IntStream、LongStream、DoubleStream。當然我們也可以用 Stream<Integer>、Stream<Long> >、Stream<Double>，但是 boxing 和 unboxing 會很耗時，所以特別為這三種基本數值型提供了對應的 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);

/*流轉換為其他數據結構*/
// 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();

 

3.3 操作的分類

接下來，當把一個數據結構包裝成 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

 

3.4 map/flatmap

 map的作用就是把 input Stream 的每一個元素，映射成 output Stream 的另外一個元素。

//轉換成大寫
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());

第一與第二個示例中可以看出，map 生成的是個 1:1 映射，每個輸入元素，都按照規則轉換成為另外一個元素。還有一些場景，是一對多映射關系的，這時需要 flatMap。如第三個示例，flatMap 把 input Stream 中的層級結構扁平化，就是將最底層元素抽出來放到一起，最終 output 的新 Stream 里面已經沒有 List 了，都是直接的數字。

 

3.5   filter

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

 

3.6    forEach

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

//打印姓名
// 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 表達式本身是可以重用的，非常方便。當需要為多核系統優化時，可以 parallelStream().forEach()，只是此時原有元素的次序沒法保證，並行的情況下將改變串行時操作的行為，此時 forEach 本身的實現不需要調整，而 Java8 以前的 for 循環 code 可能需要加入額外的多線程邏輯。

但一般認為，forEach 和常規 for 循環的差異不涉及到性能，它們僅僅是函數式風格與傳統 Java 風格的差別。

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

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

相反，具有相似功能的 intermediate 操作 peek 可以達到上述目的。如下是出現在該 api javadoc 上的一個示例。

//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 之類的關鍵字提前結束循環。

 

3.7 findFirst

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

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

//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 對程序的影響，或者迫使程序員更早的在編碼階段處理空值問題，而不是留到運行時再發現和調試。

Ps:對Optional想有更深入了解，請參考博主另一篇博文。

 

3.8 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，請留意這個區別。

 

3.9  limit/skip

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

//limit 和 skip 對運行次數的影響

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 個返回。

有一種情況是 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
[stream.StreamDW$Person@816f27d, stream.StreamDW$Person@87aac27]

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

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

 

3.10 sorted

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

//優化：排序前進行 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]

當然，這種優化是有 business logic 上的局限性的：即不要求排序后再取值。(個人覺得，這根本是意義上的不同)

 

3.11 min/max/distinct

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

//找出最長一行的長度
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 來找出不重復的單詞
//找出全文的單詞，轉小寫，並排序
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);

 

3.12  Match

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

• allMatch：Stream 中全部元素符合傳入的 predicate，返回 true
• anyMatch：Stream 中只要有一個元素符合傳入的 predicate，返回 true
• noneMatch：Stream 中沒有一個元素符合傳入的 predicate，返回 true

它們都不是要遍歷全部元素才能返回結果。例如 allMatch 只要一個元素不滿足條件，就 skip 剩下的所有元素，返回 false。

//Person類見之前所定義
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