什么是流

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

流的構(gòu)成

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

• 流的生成
  • 從 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: 一個流可以后面跟隨零個或多個 intermediate 操作。其目的主要是打開流，做出某種程度的數(shù)據(jù)映射/過濾，然后返回一個新的流，交給下一個操作使用。這類操作都是惰性化的（lazy），就是說，僅僅調(diào)用到這類方法，并沒有真正開始流的遍歷。
  • Terminal: 一個流只能有一個terminal操作，當(dāng)這個操作執(zhí)行后，流就被使用“光”了，無法再被操作。所以這必定是流的最后一個操作。Terminal操作的執(zhí)行，才會真正開始流的遍歷，并且會生成一個結(jié)果，或者一個 side effect。

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

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

• 對于一個 intermediate 操作，如果它接受的是一個無限大（infinite/unbounded）的Stream，但返回一個有限的新 Stream。
• 對于一個 terminal 操作，如果它接受的是一個無限大的Stream，但能在有限的時(shí)間計(jì)算出結(jié)果。

流的操作

• Intermediate
  • map (mapToInt, flatMap 等)、把流中的每個元素映射成另外的一個元素，flatMap 把 input Stream 中的層級結(jié)構(gòu)扁平化，就是將最底層元素抽出來放到一起，最終 output 的新 Stream 里面已經(jīng)沒有 List 了，都是直接的數(shù)字。參數(shù)是函數(shù)式接口Function

  List<String> output = wordList.stream().map(String::toUpperCase).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());
  

  • filter、過濾，根據(jù)參數(shù)返回布爾值，參數(shù)是函數(shù)式接口Predicate

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

  • distinct、去重
  • sorted、排序
  • 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());
  

  • limit、返回 Stream 的前面 n 個元素。
  • skip、扔掉前 n 個元素。
  • parallel
  • sequential
  • unordered
• Terminal
  • forEach、遍歷流中的每個元素，參數(shù)是函數(shù)式接口Consumer。forEach 是 terminal 操作，因此它執(zhí)行后，Stream 的元素就被“消費(fèi)”掉了，你無法對一個 Stream 進(jìn)行兩次 terminal 運(yùn)算。

  IntStream.of(5, 6, 7).forEach(System.out::println);
  

  • forEachOrdered
  • toArray
  • reduce、把 Stream 元素組合起來。它提供一個起始值（種子），然后依照運(yùn)算規(guī)則（BinaryOperator），和前面 Stream 的第一個、第二個、第 n 個元素組合。從這個意義上說，字符串拼接、數(shù)值的 sum、min、max、average 都是特殊的 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);
  

  • collect
  • min、最小值（為了防止NPE，返回的是Optional）
  • max、最大值（為了防止NPE，返回的是Optional）
  • count
  • anyMatch、Stream 中全部元素符合傳入的 predicate，返回 true
  • allMatch、Stream 中只要有一個元素符合傳入的 predicate，返回 true
  • noneMatch、Stream 中沒有一個元素符合傳入的 predicate，返回 true
  • findFirst、返回 Stream 的第一個元素，或者空。
  • findAny
  • iterator
• Short-circuiting
  • anyMatch
  • allMatch
  • noneMatch
  • findFirst
  • findAny
  • limit

生成流

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

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

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

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

總結(jié)

• 不是數(shù)據(jù)結(jié)構(gòu)
• 它沒有內(nèi)部存儲，它只是用操作管道從 source（數(shù)據(jù)結(jié)構(gòu)、數(shù)組、generator function、IO channel）抓取數(shù)據(jù)。
• 它也絕不修改自己所封裝的底層數(shù)據(jù)結(jié)構(gòu)的數(shù)據(jù)。例如 Stream 的 filter 操作會產(chǎn)生一個不包含被過濾元素的新 Stream，而不是從 source 刪除那些元素。
• 所有 Stream 的操作必須以 lambda 表達(dá)式為參數(shù)（因?yàn)樗邢嚓P(guān)操作都是高階函數(shù)）
• 不支持索引訪問
• 你可以請求第一個元素，但無法請求第二個，第三個，或最后一個。
• 很容易生成數(shù)組或者 List
• 惰性化
• 很多 Stream 操作是向后延遲的，一直到它弄清楚了最后需要多少數(shù)據(jù)才會開始。
• Intermediate 操作永遠(yuǎn)是惰性化的。
• 并行能力
• 當(dāng)一個 Stream 是并行化的，就不需要再寫多線程代碼，所有對它的操作會自動并行進(jìn)行的。
• 可以是無限的
  • 集合有固定大小，Stream 則不必。limit(n) 和 findFirst() 這類的 short-circuiting 操作可以對無限的 Stream 進(jìn)行運(yùn)算并很快完成。