Stream簡介

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

什么是聚合操作

在傳統(tǒng)的J2EE應用中，Java代碼經(jīng)常不得不依賴于關(guān)系型數(shù)據(jù)庫的聚合操作來完成某些操作，諸如：

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

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

Java7的排序、取值實現(xiàn)

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的排序、取值實現(xiàn)

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

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

?

Stream總覽

什么是流

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

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

而和迭代器又不同的是，Stream可以并行化操作，迭代器只能命令式地、串行化操作。顧名思義，當使用串行方法去遍歷時，每個item讀完后再讀下一個item。而使用并行去遍歷時，數(shù)據(jù)會被分成多段，其中每一個都在不同的線程中處理，然后將結(jié)果一起輸出。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的另外一大特點是，數(shù)據(jù)源本身可以是無限的。*

流的構(gòu)成

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

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

流管道（Stream Pipeline）的構(gòu)成

有多種方式生成 Stream Source：

• 從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操作，當這個操作執(zhí)行后，流就被使用“光”了，無法再被操作。所以這必定是流的最后一個操作。Terminal操作的執(zhí)行，才會真正開始流的遍歷，并且會生成一個結(jié)果，或者一個side effect。

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

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

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

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

一個流操作的示例

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

?

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

流的使用詳解

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

流的構(gòu)造與轉(zhuǎn)換

下面提供最常見的幾種構(gòu)造Stream的樣例。

構(gòu)造流的幾種常見方法

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

?

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

IntStream、LongStream、DoubleStream。當然我們也可以用Stream、Stream、Stream，但是boxing和unboxing會很耗時，所以特別為這三種基本數(shù)值型提供了對應的Stream。

Java8中還沒有提供其它數(shù)值型Stream，因為這將導致擴增的內(nèi)容較多。而常規(guī)的數(shù)值型聚合運算可以通過上面三種Stream進行。

數(shù)據(jù)流的構(gòu)造

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

?

流轉(zhuǎn)換為其它數(shù)據(jù)結(jié)構(gòu)

// 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只可以使用一個，以上示例只是為了代碼簡潔而重復使用數(shù)次。

流的操作

接下來，當把一個數(shù)據(jù)結(jié)構(gòu)包裝成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這類函數(shù)式語言，對這個方法應該很了解，它的作用就是把input Stream的每一個元素，映射成output Stream的另外一個元素。

轉(zhuǎn)換大寫

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

?

平方數(shù)

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

?

從上面例子可以看出，map生成的是個1:1映射，每個輸入元素，都按照規(guī)則轉(zhuǎn)換成為另外一個元素。還有一些場景，是一對多映射關(guān)系的，這時需要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中的層級結(jié)構(gòu)扁平化，就是將最底層元素抽出來放到一起，最終output的新Stream里面已經(jīng)沒有List了，都是直接的數(shù)字。

• filter

filter對原始Stream進行某項測試，通過測試的元素被留下來生成一個新Stream。

留下偶數(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}。

把單詞挑出來

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的每一個元素上執(zhí)行該表達式。

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

但一般認為，forEach和常規(guī)for循環(huán)的差異不涉及到性能，它們僅僅是函數(shù)式風格與傳統(tǒng)Java風格的差別。

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

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

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

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

forEach不能修改自己包含的本地變量值，也不能用break/return之類的關(guān)鍵字提前結(jié)束循環(huán)。

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

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

• reduce

這個方法的主要作用是把Stream元素組合起來。它提供一個起始值（種子），然后依照運算規(guī)則（BinaryOperator），和前面Stream的第一個、第二個、第n個元素組合。從這個意義上說，字符串拼接、數(shù)值的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(),第一個參數(shù)（空白字符）即為起始值，第二個參數(shù)（String::concat）為BinaryOperator。這類有起始值的reduce()都返回具體的對象。而對于第四個示例沒有起始值的reduce(),由于可能沒有足夠的元素，返回的是Optional，請留意這個區(qū)間。

• limit/skip

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

limit和skip對運行次數(shù)的影響

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

結(jié)果為：

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()方法的執(zhí)行次數(shù)為limit所限定的10次，而最終返回結(jié)果在跳過前3個元素后只有后面7個返回。

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

limit和skip對sorted后的運行次數(shù)無影響

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排序，然后進行l(wèi)imit操作。輸出結(jié)果為：

name2 name1 name3 name2 name4 name3 name5 name4 [stream.StreamDW$Person@816f27d, stream.StreamDW$Person@87aac27]

?

即雖然最后的返回元素數(shù)量是2，但整個管道中的sorted表達式執(zhí)行次數(shù)沒有像之前示例一樣相應減少。

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

• sorted

對Stream的排序通過sorted進行，它比數(shù)組的排序更強之處在于你可以首先對Stream進行各類map、filter、limit、skip甚至distinct來減少元素數(shù)量后，再排序，這能幫助程序明顯縮短執(zhí)行時間。對之前示例可進行優(yōu)化：

排序前進行 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);

?

結(jié)果為：

name2 name1 [stream.StreamDW$Person@6ce253f1, stream.StreamDW$Person@53d8d10a]

當然這種優(yōu)化是有business logic上的局限性的：即不要求排序后再取值

• min/max/distinct

min和max的功能也可以通過對Stream元素先排序，再findFirst來實現(xiàn)，但前者的性能會更好，為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);

?

找出全文的單詞，轉(zhuǎn)小寫，并排序

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

它們都不是要遍歷全部元素才能返回結(jié)果。例如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);

輸出結(jié)果：

All are adult? false Any child? true

進階：自己生成流

• Stream.generate

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

生成10個隨機整數(shù)

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

自實現(xiàn)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)); } }

輸出結(jié)果：

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))第三個，以此類推。

生成一個等差數(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時候管道必須有l(wèi)imit這樣的操作來限制Stream大小。

進階：用Collectors來進行reduction操作

java.util.stream.Collectors類的主要作用就是輔助進行各類有用的reduction操作，例如轉(zhuǎn)變輸出為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());

輸出結(jié)果：

Children number: 23 Adult number: 77

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

結(jié)束語

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

• 不是數(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表達式為參數(shù)
• 不支持索引訪問
• 你可以請求第一個元素，但無法請求第二個，第三個或者最后一個。不過請參閱下一項
• 很容易生成數(shù)組或者List
• 惰性化
• 很多Stream操作是向后延遲的，一直到它弄清楚了最后需要多少數(shù)據(jù)才會開始
• Intermediate操作永遠是惰性化的
• 并行能力
• 當一個Stream是并行化的，就不需要再寫多線程代碼，所有對它的操作會自動并行進行的
• 可以是無限的
• 集合有固定大小，Stream則不必。limit(n)和findFirst()這類的short-circuiting操作可以對無限的Stream進行運算并很快完成

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

轉(zhuǎn)載于:https://www.cnblogs.com/xiaoshen666/p/11083976.html

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。