Java 8 Stream 的終極技巧——Collectors 操做

1. 前言

昨天在 Collection移除元素操做 相關的文章中提到了 Collectors 。相信不少同窗對這個比較感興趣，那咱們今天就來研究一下 Collectors 。

2. Collectors 的做用

Collectors 是 Java 8 加入的操做類，位於 java.util.stream 包下。它會根據不一樣的策略將元素收集概括起來，好比最簡單經常使用的是將元素裝入Map、Set、List 等可變容器中。特別對於 Java 8 Stream Api 來講很是有用。它提供了collect() 方法來對 Stream 流進行終結操做派生出基於各類策略的結果集。咱們就藉助於 Stream 來熟悉一下 Collectors 吧。咱們依然用昨天的例子：

List<String> servers = new ArrayList<>();
        servers.add("Felordcn");
        servers.add("Tomcat");
        servers.add("Jetty");
        servers.add("Undertow");
        servers.add("Resin");

3. Java 8 中 Collectors 的方法

Collectors 提供了一系列的靜態方法供咱們使用，一般狀況咱們靜態導入便可使用。接下來咱們來看看都提供了哪些方法吧。

3.1 類型概括

這是一個系列，做用是將元素分別概括進可變容器 List、Map、Set、Collection 或者ConcurrentMap 。

Collectors.toList();
    Collectors.toMap();
    Collectors.toSet();
    Collectors.toCollection();
    Collectors.toConcurrentMap();

咱們能夠根據以上提供的 API 使用 Stream 的 collect 方法中的轉換爲熟悉的集合容器。很是簡單這裏再也不演示。

3.2 joining

將元素以某種規則鏈接起來。該方法有三種重載 joining(CharSequence delimiter) 和 joining(CharSequence delimiter,CharSequence prefix,CharSequence suffix)

//   輸出 FelordcnTomcatJettyUndertowResin
 servers.stream().collect(Collectors.joining());

 //   輸出 Felordcn,Tomcat,Jetty,Undertow,Resin
 servers.stream().collect(Collectors.joining("," ));

 //   輸出 [Felordcn,Tomcat,Jetty,Undertow,Resin]
 servers.stream().collect(Collectors.joining(",", "[", "]"));

用的比較多的是讀取 HttpServletRequest 中的 body ：

HttpServletRequest.getReader().lines().collect(Collectors.joining());

3.3 collectingAndThen

該方法先執行了一個概括操做，而後再對概括的結果進行 Function 函數處理輸出一個新的結果。

// 好比咱們將servers joining 而後轉成大寫，結果爲： FELORDCN,TOMCAT,JETTY,UNDERTOW,RESIN   
 servers.stream.collect(Collectors.collectingAndThen(Collectors.joining(","), String::toUpperCase));

3.4 groupingBy

按照條件對元素進行分組，和 SQL 中的 group by 用法有殊途同歸之妙，一般也建議使用 Java 進行分組處理以減輕數據庫壓力。groupingBy 也有三個重載方法
咱們將 servers 按照長度進行分組:

// 按照字符串長度進行分組    符合條件的元素將組成一個 List 映射到以條件長度爲key 的 Map<Integer, List<String>> 中
servers.stream.collect(Collectors.groupingBy(String::length))

若是我不想 Map 的 value 爲 List 怎麼辦？ 上面的實現實際上調用了下面的方式：

//Map<Integer, Set<String>>
 servers.stream.collect(Collectors.groupingBy(String::length, Collectors.toSet()))

我要考慮同步安全問題怎麼辦？ 固然使用線程安全的同步容器啊，那前兩種都用不成了吧！ 別急！ 咱們來推斷一下，其實第二種等同於下面的寫法:

Supplier<Map<Integer,Set<String>>> mapSupplier = HashMap::new;
 Map<Integer,Set<String>> collect = servers.stream.collect(Collectors.groupingBy(String::length, mapSupplier, Collectors.toSet()));

這就很是好辦了，咱們提供一個同步 Map 不就好了，因而問題解決了：

Supplier<Map<Integer, Set<String>>> mapSupplier = () -> Collections.synchronizedMap(new HashMap<>());
 Map<Integer, Set<String>> collect = servers.stream.collect(Collectors.groupingBy(String::length, mapSupplier, Collectors.toSet()));

其實同步安全問題 Collectors 的另外一個方法 groupingByConcurrent 給咱們提供瞭解決方案。用法和 groupingBy 差很少。

3.5 partitioningBy

partitioningBy 咱們在本文開頭的提到的文章中已經見識過了，能夠看做 groupingBy 的一個特例，基於斷言（Predicate）策略分組。這裏再也不舉例說明。

3.6 counting

該方法概括元素的的數量，很是簡單，再也不舉例說明。

3.7 maxBy/minBy

這兩個方法分別提供了查找大小元素的操做，它們基於比較器接口 Comparator 來比較 ，返回的是一個 Optional 對象。 咱們來獲取 servers 中最小長度的元素:

// Jetty  
Optional<String> min = servers.stream.collect(Collectors.minBy(Comparator.comparingInt(String::length)));

這裏其實 Resin 長度也是最小，這裏遵循了 "先入爲主" 的原則 。固然 Stream.min() 能夠很方便的獲取最小長度的元素。maxBy 一樣的道理。

3.8 summingInt/Double/Long

用來作累加計算。計算元素某個屬性的總和,相似 Mysql 的 sum 函數，好比計算各個項目的盈利總和、計算本月的所有工資總和等等。咱們這裏就計算一下 servers 中字符串的長度之和 （爲了舉例不考慮其它寫法）。

// 總長度 32 
 servers.stream.collect(Collectors.summingInt(s -> s.length()));

3.9 summarizingInt/Double/Long

若是咱們對 3.6章節-3.8章節 的操做結果都要怎麼辦？難不成咱們搞5個 Stream 流嗎？ 因此就有了 summarizingInt、summarizingDouble、summarizingLong 三個方法。
這三個方法經過對元素某個屬性的提取，會返回對元素該屬性的統計數據對象，分別對應 IntSummaryStatistics、DoubleSummaryStatistics、LongSummaryStatistics。咱們對 servers 中元素的長度進行統計：

DoubleSummaryStatistics doubleSummaryStatistics = servers.stream.collect(Collectors.summarizingDouble(String::length));
  // {count=5, sum=32.000000, min=5.000000, average=6.400000, max=8.000000}
  System.out.println("doubleSummaryStatistics.toString() = " + doubleSummaryStatistics.toString());

結果 DoubleSummaryStatistics 中包含了 總數，總和，最小值，最大值，平均值 五個指標。

3.10 mapping

該方法是先對元素使用 Function 進行再加工操做，而後用另外一個Collector 概括。好比咱們先去掉 servers 中元素的首字母，而後將它們裝入 List 。

// [elordcn, omcat, etty, ndertow, esin]
 servers.stream.collect(Collectors.mapping(s -> s.substring(1), Collectors.toList()));

有點相似 Stream 先進行了 map 操做再進行 collect ：

servers.stream.map(s -> s.substring(1)).collect(Collectors.toList());

3.11 reducing

這個方法很是有用！可是若是要了解這個就必須瞭解其參數 BinaryOperator<T> 。 這是一個函數式接口，是給兩個相同類型的量，返回一個跟這兩個量相同類型的一個結果，僞表達式爲 (T,T) -> T。默認給了兩個實現 maxBy 和 minBy ，根據比較器來比較大小並分別返回最大值或者最小值。固然你能夠靈活定製。而後 reducing 就很好理解了，元素兩兩之間進行比較根據策略淘汰一個，隨着輪次的進行元素個數就是 reduce 的。那這個有什麼用處呢？ Java 官方給了一個例子：統計每一個城市個子最高的人。

Comparator<Person> byHeight = Comparator.comparing(Person::getHeight);
     Map<String, Optional<Person>> tallestByCity = people.stream()
                          .collect(Collectors.groupingBy(Person::getCity, Collectors.reducing(BinaryOperator.maxBy(byHeight))));

結合最開始給的例子你可使用 reducing 找出最長的字符串試試。

上面這一層是根據 Height 屬性找最高的 Person ，並且若是這個屬性沒有初始化值或者沒有數據，頗有可能拿不到結果因此給出的是 Optional<Person>。 若是咱們給出了 identity 做一個基準值，那麼咱們首先會跟這個基準值進行 BinaryOperator 操做。
好比咱們給出高於 2 米 的人做爲 identity。 咱們就能夠統計每一個城市不低於 2 米 並且最高的那我的，固然若是該城市沒有人高於 2 米則返回基準值identity ：

Comparator<Person> byHeight = Comparator.comparing(Person::getHeight);
 Person identity= new Person();
           identity.setHeight(2.);
           identity.setName("identity");
     Map<String, Person> collect = persons.stream()
                        .collect(Collectors.groupingBy(Person::getCity, Collectors.reducing(identity, BinaryOperator.maxBy(byHeight))));

這時候就肯定必定會返回一個 Person 了，最起碼會是基準值identity 再也不是 Optional 。

還有些狀況，咱們想在 reducing 的時候把 Person 的身高先四捨五入一下。這就須要咱們作一個映射處理。定義一個 Function<? super T, ? extends U> mapper 來幹這個活。那麼上面的邏輯就能夠變動爲：

Comparator<Person> byHeight = Comparator.comparing(Person::getHeight);
        Person identity = new Person();
        identity.setHeight(2.);
        identity.setName("identity");
        // 定義映射 處理 四捨五入
        Function<Person, Person> mapper = ps -> {
            Double height = ps.getHeight();

            BigDecimal decimal = new BigDecimal(height);
            Double d = decimal.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
            ps.setHeight(d);
            return ps;
        };
        Map<String, Person> collect = persons.stream()
                .collect(Collectors.groupingBy(Person::getCity, Collectors.reducing(identity, mapper, BinaryOperator.maxBy(byHeight))));

4. 總結

今天咱們對 Java 8 中的 Collectors 進行了詳細的講解。若是你熟悉了 Collectors 操做 Stream 會更加駕輕就熟。固然在 Java 8 以後的 Java 9 和 Java 12 中 Collectors 都有新增的功能， 後面有時間咱們會繼續進行講解。敬請關注！

關注公衆號：Felordcn 獲取更多資訊

我的博客：https://felord.cn