JDK8 Stream API 學習
為什麼需要 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 來遍歷集合,完成相關的聚合應用邏輯。這是一種遠不夠高效、笨拙的方法。在 Java 7 中,如果要發現 type 為 grocery 的所有交易,然後返回以交易值降序排序好的交易 ID 集合,我們需要這樣寫:
清單 1. Java 7 的排序、取值實現
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()); }
而在 Java 8 使用 Stream,程式碼更加簡潔易讀;而且使用併發模式,程式執行速度更快。
清單 2. Java 8 的排序、取值實現
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 物件(可以有多次轉換),這就允許對其操作可以像鏈條一樣排列,變成一個管道,如下圖所示。
圖 1. 流管道 (Stream Pipeline) 的構成
有多種方式生成 Stream Source:
- 從 Collection 和陣列
-
- Collection.stream()
- Collection.parallelStream()
- Arrays.stream(T array) or Stream.of()
- 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 操作是必要非充分條件。
清單 3. 一個流操作的示例
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 的樣例。
清單 4. 構造流的幾種常見方法
// 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。
Java 8 中還沒有提供其它數值型 Stream,因為這將導致擴增的內容較多。而常規的數值型聚合運算可以通過上面三種 Stream 進行。
清單 5. 數值流的構造
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);
清單 6. 流轉換為其它資料結構
// 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 的另外一個元素。
清單 7. 轉換大寫
List<String> output = wordList.stream(). map(String::toUpperCase). collect(Collectors.toList());
這段程式碼把所有的單詞轉換為大寫。
清單 8. 平方數
List<Integer> nums = Arrays.asList(1, 2, 3, 4); List<Integer> squareNums = nums.stream(). map(n -> n * n). collect(Collectors.toList());
這段程式碼生成一個整數 list 的平方數 {1, 4, 9, 16}。
從上面例子可以看出,map 生成的是個 1:1 對映,每個輸入元素,都按照規則轉換成為另外一個元素。還有一些場景,是一對多對映關係的,這時需要 flatMap。
清單 9. 一對多
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。
清單 10. 留下偶數
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}。
清單 11. 把單詞挑出來
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 的每一個元素上執行該表示式。
清單 12. 列印姓名(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 上的一個示例。
清單 13. 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
這是一個 termimal 兼 short-circuiting 操作,它總是返回 Stream 的第一個元素,或者空。
這裡比較重點的是它的返回值型別:Optional。這也是一個模仿 Scala 語言中的概念,作為一個容器,它可能含有某值,或者不包含。使用它的目的是儘可能避免 NullPointerException。
清單 14. 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() 返回 OptionalDouble 等等。
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。
清單 15. 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 的方法改名而來)。
清單 16. 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 一樣。
清單 17. 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);
上面的示例對清單 13 做了微調,首先對 5 個元素的 Stream 排序,然後進行 limit 操作。輸出結果為:
name2 name1 name3 name2 name4 name3 name5 name4 [[email protected], [email protected]]
即雖然最後的返回元素數量是 2,但整個管道中的 sorted 表示式執行次數沒有像前面例子相應減少。
最後有一點需要注意的是,對一個 parallel 的 Steam 管道來說,如果其元素是有序的,那麼 limit 操作的成本會比較大,因為它的返回物件必須是前 n 個也有一樣次序的元素。取而代之的策略是取消元素間的次序,或者不要用 parallel Stream。
sorted
對 Stream 的排序通過 sorted 進行,它比陣列的排序更強之處在於你可以首先對 Stream 進行各類 map、filter、limit、skip 甚至 distinct 來減少元素數量後,再排序,這能幫助程式明顯縮短執行時間。我們對清單 14 進行優化:
清單 18. 優化:排序前進行 limit 和 skip
結果會簡單很多:
name2 name1 [[email protected], [email protected]]
當然,這種優化是有 business logic 上的侷限性的:即不要求排序後再取值。
min/max/distinct
min 和 max 的功能也可以通過對 Stream 元素先排序,再 findFirst 來實現,但前者的效能會更好,為 O(n),而 sorted 的成本是 O(n log n)。同時它們作為特殊的 reduce 方法被獨立出來也是因為求最大最小值是很常見的操作。
清單 19. 找出最長一行的長度
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 來找出不重複的單詞。
清單 20. 找出全文的單詞,轉小寫,並排序
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。對清單 13 中的 Person 類稍做修改,加入一個 age 屬性和 getAge 方法。
清單 21. 使用 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 大小。
清單 22. 生成 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 的每個元素值。這些都是維持狀態資訊的情形。
清單 23. 自實現 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)) 第三個,以此類推。
清單 24. 生成一個等差數列
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
清單 25. 按照年齡歸組
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 ……
清單 26. 按照未成年人和成年人歸組
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) 能即為全部的元素物件。
文章僅供學習參考,來源:
http://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/
相關推薦
JDK8 Stream API 學習
為什麼需要 Stream Stream 作為 Java 8 的一大亮點,它與 java.io 包裡的 InputStream 和 OutputStream 是完全不同的概念。它也不同於 StAX 對 XML 解析的 Stream,也不是 Amazon Kinesis 對大資
JDK8 Stream API
package com.hundsun.java.se.java8; import org.apache.ibatis.reflection.SystemMetaObject; import org.junit.Test; import java.sql.SQLOutput; impor
Java8學習筆記(五)--Stream API詳解[轉]
有效 編程效率 實時處理 phaser 綜合 files -- bin 並發模式 為什麽要使用StreamStream 作為 Java 8 的一大亮點,它與 java.io 包裏的 InputStream 和 OutputStream 是完全不同的概念。它也不同於 StAX
Stream相關API學習使用記錄--(一)
一、前言 在以前的工作中,業務中很多時候是需要迴圈來獲取某一個列表中的一些資料,比如獲取某一個值做業務邏輯的判斷,或者獲取其中一部分的資料,如使用狀態的標誌位等等,這個時候可能很多時候都是使用簡單的for迴圈、Foreach迴圈或者迭代器等方式,很多時候為了處理業務都是需要迴圈巢狀迴圈的。但是在Java8中
jdk8新特性Stream API
jdk8中新加入流Stream介面,主要為處理集合提供了便利,jdk8以後,在集合介面中新增加了預設的sream方法,用來生成流 物件結合Collection的原始碼增加的stream方法如下: default Stream<E> stream() { re
Java8學習筆記之Stream API
Stream是Java8引入的一個重度使用lambda表示式的API。 Stream可以用流的方式處理資料集合,在Java8之前,我們處理這些集合,是需要迭代器的,比如iterator,這是外部迭代;而Stream是內部迭代,我們不用關心集合內部元素是如何
Java 8 Stream API具體解釋
介紹 lis 控制臺輸出 output 排序。 case 編程效率 func 遍歷 Java 8 Stream API具體解釋 一、Stream API介紹 Java 8引入了全新的Stream API,此Stream與Java I/O包裏的In
Stream API
entity getc treemap arraylist 一個 無限 ica pri int 引例: 1 List<String> strList = Arrays.asList("zhaojigang","nana","tianya","n
金蝶K3 APi學習資料
sub soa 處理 eps receive 計量單位 app rec leo 外部數據交換服務使用參考 目錄 目錄.. 1 概述.. 3 公共服務 (Public.asmx). 4 AisQuery服務.. 4 GetAisType服務.. 4 DeleteItemQ
Canvas對畫布及文字控制基礎API學習
style 也不能 不能 pan 平移 spa 畫布 bsp ont 這次純API練習,比較簡單,但是是為了之後的結合項目打基礎的,所以也不能忽視它,下面開始: Canvas的平移、旋轉、縮放 ①、Canvas的平移: ②、Canvas的旋轉: ③、Ca
Java 8 : Stream API 練習
rri setname 增強 內部 new collector names pri ons //店鋪屬性類 public class Property { String name; // 距離,單位:米 Integer distance; //
SpringdataJpa的官方API學習
mon inter req pre 概念 mic spring 總數 tin (將對Springdata JPA的API 第三章之後進行解釋) 一 . Core concepts(核心概念) 1.springdata中的中心接口是——Repository。這個接口沒有什
java9新特性-13-增強的 Stream API
空指針異常 分數 單元 空指針 nta apt 好的 for 分享圖片 1.使用說明 Java 的 Steam API 是java標準庫最好的改進之一,讓開發者能夠快速運算,從而能夠有效的利用數據並行計算。Java 8 提供的 Steam 能夠利用多核架構實現聲明式的
Java8實戰Lambda和Stram API學習
nba lis bool date UC AD action print family public class Trader{ private String name; private String city; public Trader(St
[java]Stream API——reduce
聚合操作 得到 span 用戶 red item 計算 integer 循環 聚合操作reduce T reduce(T identity, BinaryOperator accumulator) 代碼: int value = Stream.of(1, 2, 3, 4)
[java]Stream API——collect
求和 pin -s mil toc tor 最大 api system 一、R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner) supplier:一個能創造目標類型實例的方法。
Node.js API 學習筆記
api mat 函數 str 學習 cap 字符串 url resolve 常用 API 學習筆記 url 函數 url.parse: 解析 url 地址 url.resolve: 向 url 地址添加或替換字段 url.format: 生成 url 地址 querys
zabbix--api學習之路--get_hostgroup獲取
獲取 document lib 返回 quest cat ber param -s api:hostgroup.get url:https://www.zabbix.com/documentation/3.4/zh/manual/api/reference/hostgro
Java 8 新特性——Stream API
目錄 1. 什麼是stream 2. Stream操作三個步驟 3. 建立Stream 4. Stream 的中間操作 5. Stream 的終止操作 Stream API(java.util.stream.*)。 &n
JDK8 Stream 初識
點這裡 Stream作為jdk8的一種重要特性,我們應該瞭解多一些。 為什麼會有Stream? 在Stream出現之前,我們對集合中的元素進行一些操作需要先遍歷每個元素再進行操作。如: LinkedHashMap<String, Integer> linkedH