java8的學習

java 8 新特性

java8 的lamdba表達式

以前的老的for循環

public void fore(){
    for(int i = 0; i < 10 ;i++){
        system.out.println("數去結果是："+ i)；
    }
}
           

for的增強循環

public void forEach(){
    /**這是user對象的集合，周遊user**/
    for(User u : userList){
        System.out.println("輸出的結果：" + u.toString());
    }
}
           

java8 的lamdba表達式

public void lamdba(){
    userList.foreach(e-(system.out.println(e)));
}
           

關鍵是

()->

,如果是單個參數可寫可不寫，如果是多個參數的話，中間用逗号隔開，

->

符号後面如果有多個程式，那麼就需要添加括号。

調用對象的方法，可以使用

::

來調用方法，例如

class User (
    private String name;
    private String sex;

    public String getName(){
        return this.name;
    }
)
           

我們在調用的時候可以這樣調用，User :: getName() 來擷取user對象的名稱。

java8 的stream表達式

擷取流的方式

Stream 不是集合元素，它不是資料結構并不儲存資料，它是有關算法和計算的，它更像一個進階版本的 Iterator。原始版本的 Iterator，使用者隻能顯式地一個一個周遊元素并對其執行某些操作；進階版本的 Stream，使用者隻要給出需要對其包含的元素執行什麼操作，比如 “過濾掉長度大于 10 的字元串”、“擷取每個字元串的首字母”等，Stream 會隐式地在内部進行周遊，做出相應的資料轉換。

Stream 就如同一個疊代器（Iterator），單向，不可往複，資料隻能周遊一次，周遊過一次後即用盡了，就好比流水從面前流過，一去不複返。

而和疊代器又不同的是，Stream 可以并行化操作，疊代器隻能指令式地、串行化操作。顧名思義，當使用串行方式去周遊時，每個 item 讀完後再讀下一個 item。而使用并行去周遊時，資料會被分成多個段，其中每一個都在不同的線程中處理，然後将結果一起輸出。Stream 的并行操作依賴于 Java7 中引入的 Fork/Join 架構（JSR166y）來拆分任務和加速處理過程。

流的構成

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

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

集合生成流的方式

集合時我們使用Collection.stream(),Collection.parallelStream();

數組生成流的方式

String[] str = {"a","b","c"};
Arrays.stream(str);
Arrays.asList(str).stream();
           

使用Stream生成流

Stream.of(dd);// Stream.iterate();

檔案生成流的方法

java.io.BufferedReader.lines()；

long uniqueWords = 0; 
try(
    Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())
    ){ 
uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" ")))
 .distinct() 
 .count(); 
} 
catch(IOException e){ 
}
           

建立無限流

Stream API提供了兩個靜态方法來從函數生成流：Stream.iterate和Stream.generate。這兩個操作可以建立所謂的無限流：不像從固定集合建立的流那樣有固定大小的流。由iterate和generate産生的流會用給定的函數按需建立值，是以可以無窮無盡地計算下去！

使用Stream.iterate()來建立

流的操作類型分為兩種：

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

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

在對于一個 Stream 進行多次轉換操作 (Intermediate 操作)，每次都對 Stream 的每個元素進行轉換，而且是執行多次，這樣時間複雜度就是 N（轉換次數）個 for 循環裡把所有操作都做掉的總和嗎？其實不是這樣的，轉換操作都是 lazy 的，多個轉換操作隻會在 Terminal 操作的時候融合起來，一次循環完成。我們可以這樣簡單的了解，Stream 裡有個操作函數的集合，每次轉換操作就是把轉換函數放入這個集合中，在 Terminal 操作的時候循環 Stream 對應的集合，然後對每個元素執行所有的函數。

流的構造與轉換

下面提供最常見的幾種構造 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、Stream >、Stream，但是 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

舉例各個關鍵操作的用法

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

[stream.StreamDW P e r s o n @ 816 f 27 d , s t r e a m . S t r e a m D W [email protected], stream.StreamDW Person@816f27d,stream.StreamDW[email protected]]

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

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

sorted

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

清單 18. 優化：排序前進行 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 P e r s o n @ 6 c e 253 f 1 , s t r e a m . S t r e a m D W [email protected], stream.StreamDW Person@6ce253f1,stream.StreamDW[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. 生成一個等差數列

輸出結果：

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) 能即為全部的元素對象。

資料流的操作

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

映射到數值流

将流轉換為特化版本的常用方法是mapToInt、mapToDouble和mapToLong。這些方法和前面說的map方法的工作方式一樣，隻是它們傳回的是一個特化流，而不是Stream。

int calories = menu.stream() 
                    .mapToInt(Dish::getCalories) 
                    .sum();
           

這個流傳回的是基本類型的值，不是流，是以不能繼續進行流的其他操作了。

轉換回對象流(boxed())

同樣，一旦有了數值流，你可能會想把它轉換回非特化流。例如，IntStream上的操作隻能産生原始整數： IntStream 的 map 操作接受的 Lambda 必須接受 int 并傳回 int （一個IntUnaryOperator）。但是你可能想要生成另一類值，比如Dish。為此，你需要通路Stream接口中定義的那些更廣義的操作。要把原始流轉換成一般流（每個int都會裝箱成一個Integer），可以使用boxed方法，如下所示：

IntStream intStream = menu.stream().mapToInt(Dish::getCalories); 
Stream<Integer> stream = intStream.boxed();
           

預設值OptionalInt

求和的那個例子很容易，因為它有一個預設值：0。但是，如果你要計算IntStream中的最大元素，就得換個法子了，因為0是錯誤的結果。如何區分沒有元素的流和最大值真的是0的流呢？

前面我們介紹了Optional類，這是一個可以表示值存在或不存在的容器。Optional可以用Integer、String等參考類型來參數化。對于三種原始流特化，也分别有一個Optional原始類型特化版本：OptionalInt、OptionalDouble和OptionalLong。

例如，要找到IntStream中的最大元素，可以調用max方法，它會傳回一個OptionalInt：

OptionalInt maxCalories = menu.stream() 
                                .mapToInt(Dish::getCalories) 
                                .max(); 
           

現在，如果沒有最大值的話，你就可以顯式處理OptionalInt去定義一個預設值了：

int max = maxCalories.orElse(1);

collect（資料收集器）

更易複合和重用。收集器非常有用，因為用它可以簡潔而靈活地定義collect用來生成結果集合的标準。更具體地說，對流調用collect方法将對流中的元素觸發一個歸約操作（由Collector來參數化）。圖6-1所示的歸約操作所做的工作和代碼清單6-1中的指令式代碼一樣。它周遊流中的每個元素，并讓Collector進建立累積交易分組的Map疊代Transaction的List提取Transaction的貨币如果分組Map中沒有這種貨币的條目，就建立一個将目前周遊的Transaction加入同一貨币的Transaction的List

圖6-1 按貨币對交易分組的歸約過程一般來說，Collector會對元素應用一個轉換函數（很多時候是不展現任何效果的恒等轉換，例如toList），并将結果累積在一個資料結構中，進而産生這一過程的最終輸出。

toList()

List<Transaction> transactions = 
 transactionStream.collect(Collectors.toList());
           

counting

long howManyDishes = menu.stream().collect(Collectors.counting());

這還可以寫得更為直接：

long howManyDishes = menu.stream().count();

查找流中的最大值和最小值(max()和min())

Comparator<Dish> dishCaloriesComparator = 
 Comparator.comparingInt(Dish::getCalories); 
Optional<Dish> mostCalorieDish = 
 menu.stream() 
 .collect(maxBy(dishCaloriesComparator));
           

summingInt

它可接受一個把對象映射為求和所需int的函數，并傳回一個收集器；該收集器在傳遞給普通的collect方法後即執行我們需要的彙總操作

Collectors.summingLong和Collectors.summingDouble方法的作用完全一樣，可以用于求和字段為long或double的情況。

averagingInt

計算數值的平均數.

double avgCalories = menu.stream().collect(averagingInt(Dish::getCalories));

到目前為止，你已經看到了如何使用收集器來給流中的元素計數，找到這些元素數值屬性的最大值和最小值，以及計算其總和和平均值。不過很多時候，你可能想要得到兩個或更多這樣的結果，而且你希望隻需一次操作就可以完成。在這種情況下，你可以使用summarizingInt工廠方法傳回的收集器。例如，通過一次summarizing操作你可以就數出菜單中元素的個數，并得

到菜肴熱量總和、平均值、最大值和最小值：

IntSummaryStatistics menuStatistics = 
 menu.stream().collect(summarizingInt(Dish::getCalories)); 
           

這個收集器會把所有這些資訊收集到一個叫作IntSummaryStatistics的類裡，它提供了友善的取值（getter）方法來通路結果。列印menuStatisticobject會得到以下輸出：

IntSummaryStatistics{count=9, sum=4300, min=120, average=477.777778, max=800}

同樣，相應的summarizingLong和summarizingDouble工廠方法有相關LongSummaryStatisticsDoubleSummaryStatistics類型，适用于收集的屬性是原始類型long或double的情況。

joining(連接配接字元串)

joining工廠方法傳回的收集器會把對流中每一個對象應用toString方法得到的所有字元串連接配接成一個字元串。這意味着你把菜單中所有菜肴的名稱連接配接起來，如下所示：

請注意，joining在内部使用了StringBuilder來把生成的字元串逐個追加起來。

使用自定義的分隔符

分組

一個常見的資料庫操作是根據一個或多個屬性對集合中的項目進行分組。就像前面講到按貨币對交易進行分組的例子一樣，如果用指令式風格來實作的話，這個操作可能會很麻煩、啰嗦而且容易出錯。但是，如果用Java 8所推崇的函數式風格來重寫的話，就很容易轉化為一個非常容易看懂的語句。我們來看看這個功能的第二個例子：假設你要把菜單中的菜按照類型進行分類，有肉的放一組，有魚的放一組，其他的都放另一組。用Collectors.groupingBy工廠方法傳回的收集器就可以輕松地完成這項任務，如下所示：

Map<Dish.Type, List<Dish>> dishesByType = 
 menu.stream().collect(groupingBy(Dish::getType)); 
           

其結果是下面的Map：

{FISH=[prawns, salmon], OTHER=[french fries, rice, season fruit, pizza], MEAT=[pork, beef, chicken]}

這裡，你給groupingBy方法傳遞了一個Function（以方法引用的形式），它提取了流中每一道Dish的Dish.Type。我們把這個Function叫作分類函數，因為它用來把流中的元素分成不同的組。如圖6-4所示，分組操作的結果是一個Map，把分組函數傳回的值作為映射的鍵，把流中所有具有這個分類值的項目的清單作為對應的映射值。在菜單分類的例子中，鍵就是菜的類型，

6.3 分組 121 值就是包含所有對應類型的菜肴的清單。分類函數不一定像方法引用那樣可用，因為你想用以分類的條件可能比簡單的屬性通路器要複雜。例如，你可能想把熱量不到400卡路裡的菜劃分為“低熱量”（diet），熱量400到700卡路裡的菜劃為“普通”（normal），高于700卡路裡的劃為“高熱量”（fat）。由于Dish類的作者沒有把這個操作寫成一個方法，你無法使用方法引用，但你可以把這個邏輯寫成Lambda表達式：

public enum CaloricLevel { DIET, NORMAL, FAT } 
Map<CaloricLevel, List<Dish>> dishesByCaloricLevel = menu.stream().collect( 
 groupingBy(dish -> { 
 if (dish.getCalories() <= 400) return CaloricLevel.DIET; 
 else if (dish.getCalories() <= 700) return 
 CaloricLevel.NORMAL; 
 else return CaloricLevel.FAT; 
 } )); 
           

現在，你已經看到了如何對菜單中的菜肴按照類型和熱量進行分組，但要是想同時按照這兩個标準分類怎麼辦呢？分組的強大之處就在于它可以有效地組合。讓我們來看看怎麼做。

多級分組

要實作多級分組，我們可以使用一個由雙參數版本的Collectors.groupingBy工廠方法建立的收集器，它除了普通的分類函數之外，還可以接受collector類型的第二個參數。那麼要進行二級分組的話，我們可以把一個内層groupingBy傳遞給外層groupingBy，并定義一個為流中項目分類的二級标準，如代碼清單6-2所示。

Map<Dish.Type, Map<CaloricLevel, List<Dish>>> dishesByTypeCaloricLevel = 
menu.stream().collect( 
 groupingBy(Dish::getType, 
 groupingBy(dish -> { 
 if (dish.getCalories() <= 400) return CaloricLevel.DIET; 
 else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL; 
 else return CaloricLevel.FAT; 
 } ) 
 ) 
); 
           

這個二級分組的結果就是像下面這樣的兩級Map：

{MEAT={DIET=[chicken], NORMAL=[beef], FAT=[pork]}, FISH={DIET=[prawns], NORMAL=[salmon]}, OTHER={DIET=[rice, seasonal fruit], NORMAL=[french fries, pizza]}}

這裡的外層Map的鍵就是第一級分類函數生成的值：“fish, meat, other”，而這個Map的值又是一個Map，鍵是二級分類函數生成的值：“normal, diet, fat”。最後，第二級map的值是流中元素構成的List，是分别應用第一級和第二級分類函數所得到的對應第一級和第二級鍵的值：“salmon、pizza…”這種多級分組操作可以擴充至任意層級，n級分組就會得到一個代表n級樹形結構的n級Map。圖6-5顯示了為什麼結構相當于n維表格，并強調了分組操作的分類目的。

一般來說，把groupingBy看作“桶”比較容易明白。第一個groupingBy給每個鍵建立了一個桶。然後再用下遊的收集器去收集每個桶中的元素，以此得到n級分組。圖6-5 n層嵌套映射和n維分類表之間的等價關系

按子組收集資料

在上一節中，我們看到可以把第二個groupingBy收集器傳遞給外層收集器來實作多級分組。但進一步說，傳遞給第一個groupingBy的第二個收集器可以是任何類型，而不一定是另一個groupingBy。例如，要數一數菜單中每類菜有多少個，可以傳遞counting收集器作為groupingBy收集器的第二個參數：

Map<Dish.Type, Long> typesCount = menu.stream().collect( 
 groupingBy(Dish::getType, counting())); 
           

其結果是下面的Map：

{MEAT=3, FISH=2, OTHER=4} 還要注意，普通的單參數groupingBy(f)（其中f是分類函數）實際上是groupingBy(f, toList())的簡便寫法。再舉一個例子，你可以把前面用于查找菜單中熱量最高的菜肴的收集器改一改，按照菜的類

型分類：

Map<Dish.Type, Optional<Dish>> mostCaloricByType = 
 menu.stream() 
 .collect(groupingBy(Dish::getType, 
 maxBy(comparingInt(Dish::getCalories)))); 
           

這個分組的結果顯然是一個map，以Dish的類型作為鍵，以包裝了該類型中熱量最高的Dish的Optional作為值：{FISH=Optional[salmon], OTHER=Optional[pizza], MEAT=Optional[pork]}

注意 這個Map中的值是Optional，因為這是maxBy工廠方法生成的收集器的類型，但實際上，如果菜單中沒有某一類型的Dish，這個類型就不會對應一個Optional. empty()值，而且根本不會出現在Map的鍵中。groupingBy收集器隻有在應用分組條件後，第一次在流中找到某個鍵對應的元素時才會把鍵加入分組Map中。這意味着Optional包裝器在這裡不是很有用，因為它不會僅僅因為它是歸約收集器的傳回類型而表達一個最終可能不存在卻意外存在的值。

把收集器的結果轉換為另一種類型

因為分組操作的Map結果中的每個值上包裝的Optional沒什麼用，是以你可能想要把它們去掉。要做到這一點，或者更一般地來說，把收集器傳回的結果轉換為另一種類型，你可以使用Collectors.collectingAndThen工廠方法傳回的收集器，如下所示。代碼清單6-3 查找每個子組中熱量最高的Dish.

Map<Dish.Type, Dish> mostCaloricByType = 
 menu.stream() 
 .collect(groupingBy(Dish::getType,
 collectingAndThen( 
 maxBy(comparingInt(Dish::getCalories)), 
 Optional::get))); 
           

這個工廠方法接受兩個參數——要轉換的收集器以及轉換函數，并傳回另一個收集器。這個收集器相當于舊收集器的一個包裝，collect操作的最後一步就是将傳回值用轉換函數做一個映射。在這裡，被包起來的收集器就是用maxBy建立的那個，而轉換函數Optional::get則把傳回的Optional中的值提取出來。前面已經說過，這個操作放在這裡是安全的，因為reducing收集器永遠都不會傳回Optional.empty()。其結果是下面的Map：

{FISH=salmon, OTHER=pizza, MEAT=pork} 把好幾個收集器嵌套起來很常見，它們之間到底發生了什麼可能不那麼明顯。圖6-6可以直覺地展示它們是怎麼工作的。從最外層開始逐層向裡，注意以下幾點。

收集器用虛線表示，是以groupingBy是最外層，根據菜肴的類型把菜單流分組，得到三個子流。

groupingBy收集器包裹着collectingAndThen收集器，是以分組操作得到的每個子流

都用這第二個收集器做進一步歸約。

collectingAndThen收集器又包裹着第三個收集器maxBy。  随後由歸約收集器進行子流的歸約操作，然後包含它collectingAndThen收集器會對其結果應用Optional:get轉換函數。

對三個子流分别執行這一過程并轉換而得到的三個值，也就是各個類型中熱量最高的Dish，将成為groupingBy收集器傳回的Map中與各個分類鍵（Dish的類型）相關聯的值。