Stream簡介

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

什么是聚合操作

在傳統的J2EE應用中，Java代碼經常不得不依賴于關系型數據庫的聚合操作來完成某些操作，諸如：

• 客戶每月平均消費金額
• 最昂貴的在售商品
• 本周完成的有效訂單（排除了無效的）
• 取十個數據樣本作為首頁推薦

但在當今這個數據大爆炸的時代，在數據來源多樣化、數據海量化的今天，很多時候不得不脫離RDBMS,或者以底層返回的數據為基礎進行更上層的數據統計。而Java的集合API中，僅僅有極少量的輔助性方法，更多的時候是程序員需要用Iterator來遍歷集合，完成相關的聚合應用邏輯。這是一種遠不夠高效、笨拙的方法。在Java7中，如果要發現type為grocery的所有交易，然后返回以交易值降序排序好的交易ID集合，我們需要這樣寫：

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的排序、取值實現

Java8中使用Stream，代碼更加簡潔易讀，而且使用并發模式，程序執行速度更快。

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

?

Stream總覽

什么是流

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

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

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

流的構成

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

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

流管道（Stream Pipeline）的構成

有多種方式生成 Stream Source：

• 從Collection和數組

  • Collection.stream()
  • Collection.parallelStream()
  • Arrays.stream(T array) or Stream.of()

• 從BufferedReader

  • java.io.BufferedReader.lines()\

• 靜態工廠

  • java.util.stream.IntStream.range()
  • java.nio.file.Files.walk()

• 自己構建

  • java.util.Spliterator

• 其它

  • Random.ints()
  • BitSet.stream()
  • Pattern.splitAsStream(java.lang.CharSequence)
  • JarFile.stream()

流的操作類型分為兩種：

• 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操作是必要非充分條件。

一個流操作的示例

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

?

stream()獲取當前小物件的source,filter和mapToInt為intermediate操作，進行數據篩選和轉換，最后一個sum()為terminal操作，對符合條件的全部小物件作重量求和。

流的使用詳解

簡單說，對Stream的使用就是實現一個filter-map-reduce過程，產生一個最終結果，或者導致一個副作用（side effect）。

流的構造與轉換

下面提供最常見的幾種構造Stream的樣例。

構造流的幾種常見方法

// 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、Stream、Stream，但是boxing和unboxing會很耗時，所以特別為這三種基本數值型提供了對應的Stream。

Java8中還沒有提供其它數值型Stream，因為這將導致擴增的內容較多。而常規的數值型聚合運算可以通過上面三種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();

?

注：一個Stream只可以使用一個，以上示例只是為了代碼簡潔而重復使用數次。

流的操作

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

接下來下面看一下Stream的比較典型用法。

• map/flatMap

先來看map。如果熟悉scala這類函數式語言，對這個方法應該很了解，它的作用就是把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());

?

從上面例子可以看出，map生成的是個1:1映射，每個輸入元素，都按照規則轉換成為另外一個元素。還有一些場景，是一對多映射關系的，這時需要flatMap。

一對多

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中的層級結構扁平化，就是將最底層元素抽出來放到一起，最終output的新Stream里面已經沒有List了，都是直接的數字。

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

?

經過條件“被2整除”的filter，剩下的數字為{2,4,6}。

把單詞挑出來

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方法接收一個Lambda表達式，然后在Stream的每一個元素上執行該表達式。

打印姓名（forEach和pre-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是為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之類的關鍵字提前結束循環。

• findFirst

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

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

• 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。

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

?

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

• 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]

這是一個有10000個元素的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的Stream管道來說，如果其元素是有序的，那么limit操作的成本會比較大，因為它的返回對象必須是前n個也有一樣次序的元素。取而代之的策略是取消元素間的次序，或者不要用parallel Stream。

• 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上的局限性的：即不要求排序后再取值

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

?

找出全文的單詞，轉小寫，并排序

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有三個match方法，從語義上說：

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

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

使用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

進階：自己生成流

• Stream.generate

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

生成10個隨機整數

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()還接受自己實現的Supplier。例如在構造海量測試數據的時候，用某種自動的規則給每一個變量賦值；或者依據公式計算Stream的每個元素值。這些都是維持狀態信息的情形。

自實現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)); } }

輸出結果：

StormTestUser1, 9 StormTestUser2, 12 StormTestUser3, 88 StormTestUser4, 51 StormTestUser5, 22 StormTestUser6, 28 StormTestUser7, 81 StormTestUser8, 51 StormTestUser9, 4 StormTestUser10, 76

• 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 + " "));

輸出結果：

0 3 6 9 12 15 18 21 24 27

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

進階：用Collectors來進行reduction操作

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

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

上面的示例，首先生成100人的信息，然后按照年齡歸組，相同年齡的人放到同一個list中，可以看到如下的輸出：

Age 0 = 2 Age 1 = 2 Age 5 = 2 Age 8 = 1 Age 9 = 1 Age 11 = 2 ……

按照未成年人和成年人歸組

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

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

結束語

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

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

原文 ：https://blog.csdn.net/ffj0721/article/details/81034306

轉載于:https://www.cnblogs.com/xiaoshen666/p/11083976.html

總結

以上是生活随笔為你收集整理的JDK1.8中的Stream详解的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。