Java 8系列之Stream的强大工具Collector
Stream系列：
概述
前面我們使用過collect(toList())，在流中生成列表。實際開發過程中，List又是我們經常用到的數據結構，但是有時候我們也希望Stream能夠轉換生成其他的值，比如Map或者set，甚至希望定制生成想要的數據結構。
collect也就是收集器，是Stream一種通用的、從流生成復雜值的結構。只要將它傳給collect方法，也就是所謂的轉換方法，其就會生成想要的數據結構。這里不得不提下，Collectors這個工具庫，在該庫中封裝了相應的轉換方法。當然，Collectors工具庫僅僅封裝了常用的一些情景，如果有特殊需求，那就要自定義了。
顯然，List是能想到的從流中生成的最自然的數據結構， 但是有時人們還希望從流生成其他值， 比如 Map 或 Set， 或者你希望定制一個類將你想要的東西抽象出來。
前面已經講過，僅憑流上方法的簽名，就能判斷出這是否是一個及早求值的操作。 reduce操作就是一個很好的例子， 但有時人們希望能做得更多。?
這就是收集器，一種通用的、從流生成復雜值的結構。只要將它傳給collect 方法，所有的流就都可以使用它了。
<R, A> R collect(Collector<? super T, A, R> collector);
<R> R collect(Supplier<R> supplier,BiConsumer<R, ? super T> accumulator,?BiConsumer<R, R> combiner);
輔助接口
Supplier
Supplier<T>接口是一個函數接口，該接口聲明了一個get方法，主要用來創建返回一個指定數據類型的對象。
- T：指定的數據類型
BiConsumer
BiConsumer<T, U>接口是一個函數接口，該接口聲明了accept方法，并無返回值，該函數接口主要用來聲明一些預期操作。
同時，該接口定義了一個默認方法andThen，該方法接受一個BiConsumer，并返回一個組合的BiConsumer，其會按照順序執行操作。如果執行任一操作拋出異常，則將其傳遞給組合操作的調用者。 如果執行此操作拋出異常，將不執行后操作(after)。
@FunctionalInterface public interface BiConsumer<T, U> {void accept(T t, U u);default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> after) {Objects.requireNonNull(after);return (l, r) -> {accept(l, r);after.accept(l, r);};} }BinaryOperator
BinaryOperator接口繼承于BiFunction接口，該接口指定了apply方法執行的參數類型及返回值類型均為T。
@FunctionalInterface public interface BinaryOperator<T> extends BiFunction<T,T,T> {public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {Objects.requireNonNull(comparator);return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;}public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {Objects.requireNonNull(comparator);return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;} }@FunctionalInterface public interface BiFunction<T, U, R> {R apply(T t, U u);default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {Objects.requireNonNull(after);return (T t, U u) -> after.apply(apply(t, u));} }Function
Funtion是一個函數接口，其內定義了一個轉換函數，將T轉換為R。比如Stream中的map方法便是接受該函數參數，將T轉換為R。
@FunctionalInterface public interface Function<T, R> {/*** 轉換函數，將T轉換為R*/R apply(T t);/*** 返回一個組合函數Function，首先執行before,然后再執行該Function** 如果兩個函數的求值都拋出異常，它將被中繼到組合函數的調用者。* 如果before為null，將會拋出NullPointerException*/default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {Objects.requireNonNull(before);return (V v) -> apply(before.apply(v));}/*** 返回一個組合函數Function，首先執行Function,然后再執行after** 如果兩個函數的求值都拋出異常，它將被中繼到組合函數的調用者。* 如果after為null，將會拋出NullPointerException*/default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {Objects.requireNonNull(after);return (T t) -> after.apply(apply(t));}/*** 將輸入參數返回的函數*/static <T> Function<T, T> identity() {return t -> t;} }Collector
Collector是Stream的可變減少操作接口，可變減少操作包括：將元素累積到集合中，使用StringBuilder連接字符串;計算元素相關的統計信息，例如sum，min，max或average等。Collectors(類收集器)提供了許多常見的可變減少操作的實現。
Collector<T, A, R>接受三個泛型參數，對可變減少操作的數據類型作相應限制：
- T：輸入元素類型
- A：縮減操作的可變累積類型（通常隱藏為實現細節）
- R：可變減少操作的結果類型
Collector接口聲明了4個函數，這四個函數一起協調執行以將元素累積到可變結果容器中，并且可以選擇地對結果進行最終的變換.
- Supplier<A> supplier(): 創建新的結果容器
- BiConsumer<A, T> accumulator(): 將元素添加到結果容器
- BinaryOperator<A> combiner(): 將兩個結果容器合并為一個結果容器
- Function<A, R> finisher(): 對結果容器作相應的變換
在Collector接口的characteristics方法內，可以對Collector聲明相關約束
- Set<Characteristics> characteristics():
而Characteristics是Collector內的一個枚舉類，聲明了CONCURRENT、UNORDERED、IDENTITY_FINISH等三個屬性，用來約束Collector的屬性。
- CONCURRENT：表示此收集器支持并發，意味著允許在多個線程中，累加器可以調用結果容器
- UNORDERED：表示收集器并不按照Stream中的元素輸入順序執行
- IDENTITY_FINISH：表示finisher實現的是識別功能，可忽略。?
注：如果一個容器僅聲明CONCURRENT屬性，而不是UNORDERED屬性，那么該容器僅僅支持無序的Stream在多線程中執行。
身份約束和相關性約束
Stream可以順序執行，或者并發執行，或者順序并發執行，為了保證Stream可以產生相同的結果，收集器函數必須滿足身份約束和相關項約束。
身份約束說，對于任何部分累積的結果，將其與空結果容器組合必須產生等效結果。也就是說，對于作為任何系列的累加器和組合器調用的結果的部分累加結果a，a必須等于combiner.apply（a，supplier.get（））。
相關性約束說，分裂計算必須產生等效的結果。也就是說，對于任何輸入元素t1和t2，以下計算中的結果r1和r2必須是等效的：
A a1 = supplier.get（）; accumulator.accept（a1，t1）; accumulator.accept（a1，t2）; R r1 = finisher.apply（a1）; // result without splittingA a2 = supplier.get（）; accumulator.accept（a2，t1）; A a3 = supplier.get（）; accumulator.accept（a3，t2）; R r2 = finisher.apply（combiner.apply（a2，a3））;?創建Collector
自定義Collector
Java 8系列之重構和定制收集器
基于Collector工具庫
在Collector工具庫中，聲明了許多常用的收集器,以供我們快速創建一個收集器。前面我們已經了解到，收集器函數必須滿足身份約束和相關項約束。而基于Collector實現簡化的庫（如Stream.collect（Collector））創建收集器時，必須遵守以下約束：
轉換成其他集合
對于前面提到了很多Stream的鏈式操作，但是，我們總是要將Stream生成一個集合，比如：
- 已有代碼是為集合編寫的， 因此需要將流轉換成集合傳入；
- 在集合上進行一系列鏈式操作后， 最終希望生成一個值；
- 寫單元測試時， 需要對某個具體的集合做斷言。
有些Stream可以轉成集合，比如前面提到toList,生成了java.util.List 類的實例。當然了，還有還有toSet和toCollection，分別生成 Set和Collection 類的實例。
toList
示例：
List<Integer> collectList = Stream.of(1, 2, 3, 4).collect(Collectors.toList()); System.out.println("collectList: " + collectList); // 打印結果 // collectList: [1, 2, 3, 4]toSet
示例：
Set<Integer> collectSet = Stream.of(1, 2, 3, 4).collect(Collectors.toSet()); System.out.println("collectSet: " + collectSet); // 打印結果 // collectSet: [1, 2, 3, 4]toCollection
通常情況下，創建集合時需要調用適當的構造函數指明集合的具體類型：
List<Artist> artists = new ArrayList<>();但是調用toList或者toSet方法時，不需要指定具體的類型，Stream類庫會自動推斷并生成合適的類型。當然，有時候我們對轉換生成的集合有特定要求，比如，希望生成一個TreeSet,而不是由Stream類庫自動指定的一種類型。此時使用toCollection，它接受一個函數作為參數， 來創建集合。
值得我們注意的是，看Collectors的源碼，因為其接受的函數參數必須繼承于Collection，也就是意味著Collection并不能轉換所有的繼承類，最明顯的就是不能通過toCollection轉換成Map
toMap
如果生成一個Map,我們需要調用toMap方法。由于Map中有Key和Value這兩個值，故該方法與toSet、toList等的處理方式是不一樣的。toMap最少應接受兩個參數，一個用來生成key，另外一個用來生成value。toMap方法有三種變形：
- toMap(Function<? super T, ? extends K> keyMapper,Function<? super T, ? extends U> valueMapper)
注：若Stream中有重復的值,導致Map中key重復，在運行時會報異常java.lang.IllegalStateException: Duplicate key **
- toMap(Function
轉成值
使用collect可以將Stream轉換成值。maxBy和minBy允許用戶按照某個特定的順序生成一個值。
- averagingDouble:求平均值，Stream的元素類型為double
- averagingInt:求平均值，Stream的元素類型為int
- averagingLong:求平均值，Stream的元素類型為long
- counting:Stream的元素個數
- maxBy:在指定條件下的，Stream的最大元素
- minBy:在指定條件下的，Stream的最小元素
- reducing: reduce操作
- summarizingDouble:統計Stream的數據(double)狀態，其中包括count，min，max，sum和平均。
- summarizingInt:統計Stream的數據(int)狀態，其中包括count，min，max，sum和平均。
- summarizingLong:統計Stream的數據(long)狀態，其中包括count，min，max，sum和平均。
- summingDouble:求和，Stream的元素類型為double
- summingInt:求和，Stream的元素類型為int
- summingLong:求和，Stream的元素類型為long
示例：
Optional<Integer> collectMaxBy = Stream.of(1, 2, 3, 4).collect(Collectors.maxBy(Comparator.comparingInt(o -> o))); System.out.println("collectMaxBy:" + collectMaxBy.get()); // 打印結果 // collectMaxBy:4分割數據塊
collect的一個常用操作是將Stream分解成兩個集合。假如有一個數字的Stream，我們可能希望將其分割成兩個集合，一個是偶數集合，另外一個是奇數集合。我們首先想到的就是過濾操作，通過兩次過濾操作，很簡單的就完成了我們的需求。
但是這樣操作起來有問題。首先，為了執行兩次過濾操作，需要有兩個流。其次，如果過濾操作復雜，每個流上都要執行這樣的操作， 代碼也會變得冗余。
這里我們就不得不說Collectors庫中的partitioningBy方法，它接受一個流，并將其分成兩部分：使用Predicate對象，指定條件并判斷一個元素應該屬于哪個部分，并根據布爾值返回一個Map到列表。因此對于key為true所對應的List中的元素，滿足Predicate對象中指定的條件；同樣，key為false所對應的List中的元素,不滿足Predicate對象中指定的條件
這樣，使用partitioningBy，我們就可以將數字的Stream分解成奇數集合和偶數集合了。
Map<Boolean, List<Integer>> collectParti = Stream.of(1, 2, 3, 4).collect(Collectors.partitioningBy(it -> it % 2 == 0)); System.out.println("collectParti : " + collectParti); // 打印結果 // collectParti : {false=[1, 3], true=[2, 4]}
數據分組
數據分組是一種更自然的分割數據操作， 與將數據分成true和false兩部分不同，可以使用任意值對數據分組。
調用Stream的collect方法，傳入一個收集器,groupingBy接受一個分類函數，用來對數據分組，就像partitioningBy一樣，接受一個?Predicate對象將數據分成true和false兩部分。我們使用的分類器是一個Function對象，和map操作用到的一樣。
示例：
Map<Boolean, List<Integer>> collectGroup= Stream.of(1, 2, 3, 4).collect(Collectors.groupingBy(it -> it > 3)); System.out.println("collectGroup : " + collectGroup); // 打印結果 // collectGroup : {false=[1, 2, 3], true=[4]}注：看groupingBy和partitioningBy的例子，他們的效果都是一樣的，都是將Stream的數據進行了分割處理并返回一個Map。可能舉的例子給你帶來了誤區，實際上他們兩個完全是不一樣的。
partitioningBy是根據指定條件，將Stream分割，返回的Map為Map
字符串
有時候，我們將Stream的元素(String類型)最后生成一組字符串。比如在Stream.of(“1”, “2”, “3”, “4”)中，將Stream格式化成“1，2，3，4”。
如果不使用Stream，我們可以通過for循環迭代實現。
ArrayList<Integer> list = new ArrayList<>(); list.add(1); list.add(2); list.add(3); list.add(4);StringBuilder sb = new StringBuilder();for (Integer it : list) {if (sb.length() > 0) {sb.append(",");}sb.append(it);} System.out.println(sb.toString()); // 打印結果 // 1,2,3,4在Java 1.8中，我們可以使用Stream來實現。這里我們將使用 Collectors.joining 收集Stream中的值，該方法可以方便地將Stream得到一個字符串。joining函數接受三個參數，分別表示允（用以分隔元素）、前綴和后綴。
示例：
String strJoin = Stream.of("1", "2", "3", "4").collect(Collectors.joining(",", "[", "]")); System.out.println("strJoin: " + strJoin); // 打印結果 // strJoin: [1,2,3,4]組合Collector
前面，我們已經了解到Collector的強大，而且非常的實用。如果將他們組合起來，是不是更厲害呢？看前面舉過的例子，在數據分組時，我們得到了分組后的數據列表 collectGroup : {false=[1, 2, 3], true=[4]}。如果我們的要求更高點，我們不需要分組后的列表，只要得到分組后列表的個數就好了。
這時候，很多人下意識的都會想到，遍歷Map就好了，然后使用list.size（）,就可以輕松的得到各個分組的列表個數。
// 分割數據塊 Map<Boolean, List<Integer>> collectParti = Stream.of(1, 2, 3, 4).collect(Collectors.partitioningBy(it -> it % 2 == 0));Map<Boolean, Integer> mapSize = new HashMap<>(); collectParti.entrySet().forEach(entry -> mapSize.put(entry.getKey(), entry.getValue().size()));System.out.println("mapSize : " + mapSize); // 打印結果 // mapSize : {false=2, true=2}在partitioningBy方法中，有這么一個變形：
Map<Boolean, Long> partiCount = Stream.of(1, 2, 3, 4).collect(Collectors.partitioningBy(it -> it.intValue() % 2 == 0,Collectors.counting())); System.out.println("partiCount: " + partiCount); // 打印結果 // partiCount: {false=2, true=2}在partitioningBy方法中，我們不僅傳遞了條件函數，同時傳入了第二個收集器，用以收集最終結果的一個子集，這些收集器叫作下游收集器。收集器是生成最終結果的一劑配方，下游收集器則是生成部分結果的配方，主收集器中會用到下游收集器。這種組合使用收集器的方式， 使得它們在 Stream 類庫中的作用更加強大。
那些為基本類型特殊定制的函數，如averagingInt、summarizingLong等，事實上和調用特殊Stream上的方法是等價的，加上它們是為了將它們當作下游收集器來使用的。
---------------------?
作者：行云間?
來源：CSDN?
原文：https://blog.csdn.net/IO_Field/article/details/54971608?
版權聲明：本文為博主原創文章，轉載請附上博文鏈接！
總結
以上是生活随笔為你收集整理的Java 8系列之Stream的强大工具Collector的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Java 8系列之Lambda表达式
- 下一篇： Java 8系列之重构和定制收集器