Java 8 Stream 之Collectors 类

╰+攻爆jí腚メ 2023-10-10 12:17 33阅读 0赞

## Collectors 类的静态工厂方法 ##

<table> 
 <thead> 
  <tr> 
   <th>工厂方法</th> 
   <th>返回类型</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>toList</td> 
   <td><code>List&lt;T&gt;</code></td> 
   <td>把流中所有项目收集到一个 List</td> 
  </tr> 
  <tr> 
   <td>toSet</td> 
   <td><code>Set&lt;T&gt;</code></td> 
   <td>把流中所有项目收集到一个 Set，删除重复项</td> 
  </tr> 
  <tr> 
   <td>toCollection</td> 
   <td><code>Collection&lt;T&gt;</code></td> 
   <td>把流中所有项目收集到给定的供应源创建的集合<code>menuStream.collect(toCollection(), ArrayList::new)</code></td> 
  </tr> 
  <tr> 
   <td>counting</td> 
   <td>Long</td> 
   <td>计算流中元素的个数</td> 
  </tr> 
  <tr> 
   <td>sumInt</td> 
   <td>Integer</td> 
   <td>对流中项目的一个整数属性求和</td> 
  </tr> 
  <tr> 
   <td>averagingInt</td> 
   <td>Double</td> 
   <td>计算流中项目 Integer 属性的平均值</td> 
  </tr> 
  <tr> 
   <td>summarizingInt</td> 
   <td>IntSummaryStatistics</td> 
   <td>收集关于流中项目 Integer 属性的统计值，例如最大、最小、 总和与平均值</td> 
  </tr> 
  <tr> 
   <td>joining</td> 
   <td>String</td> 
   <td>连接对流中每个项目调用 toString 方法所生成的字符串<code>collect(joining(", "))</code></td> 
  </tr> 
  <tr> 
   <td>maxBy</td> 
   <td><code>Optional&lt;T&gt;</code></td> 
   <td>一个包裹了流中按照给定比较器选出的最大元素的 Optional， 或如果流为空则为 Optional.empty()</td> 
  </tr> 
  <tr> 
   <td>minBy</td> 
   <td><code>Optional&lt;T&gt;</code></td> 
   <td>一个包裹了流中按照给定比较器选出的最小元素的 Optional， 或如果流为空则为 Optional.empty()</td> 
  </tr> 
  <tr> 
   <td>reducing</td> 
   <td>归约操作产生的类型</td> 
   <td>从一个作为累加器的初始值开始，利用 BinaryOperator 与流 中的元素逐个结合，从而将流归约为单个值<code>累加int totalCalories = menuStream.collect(reducing(0, Dish::getCalories, Integer::sum));</code></td> 
  </tr> 
  <tr> 
   <td>collectingAndThen</td> 
   <td>转换函数返回的类型</td> 
   <td>包裹另一个收集器，对其结果应用转换函数<code>int howManyDishes = menuStream.collect(collectingAndThen(toList(), List::size))</code></td> 
  </tr> 
  <tr> 
   <td>groupingBy</td> 
   <td><code>Map&lt;K, List&lt;T&gt;&gt;</code></td> 
   <td>根据项目的一个属性的值对流中的项目作问组，并将属性值作 为结果 Map 的键</td> 
  </tr> 
  <tr> 
   <td>partitioningBy</td> 
   <td><code>Map&lt;Boolean,List&lt;T&gt;&gt;</code></td> 
   <td>根据对流中每个项目应用谓词的结果来对项目进行分区</td> 
  </tr> 
 </tbody> 
</table>

### Collectors ###

在Collectors类中有所有的预定义实现。一般常见做法是使用下面的静态导入来提高可读性:

import static java.util.stream.Collectors.*;

或者单个导入你选择的collectors：

import static java.util.stream.Collectors.toList;
    import static java.util.stream.Collectors.toMap;
    import static java.util.stream.Collectors.toSet;

下面所有示例将使用以下演示数据集合

List<String> givenList = Arrays.asList("a", "bb", "ccc", "dd");

#### Collectors.toList() ####

ToList 方法可以收集所有流中元素至List实例。需要注意的是，使用该方法不能假设任何List的特定实现，如果你想指定List实现，需要使用toCollection 代替.下面示例创建一个流实例表示元素序列，然后收集至List实例对象中。

List<String> result = givenList.stream().collect(toList());

#### Collectors.toSet() ####

ToSet 方法可以收集所有流中元素至Set 实例.需要注意的是，使用该方法不能假设任何Set的特定实现，如果你想指定Set实现，需要使用toCollection 代替.下面示例创建一个流实例表示元素序列，然后收集至Set例对象中

Set<String> result = givenList.stream().collect(toSet());

Set不包含重复元素。如果集合中有重复元素，则set中仅保留一个：

List<String> listWithDuplicates = Arrays.asList("a", "bb", "c", "d", "bb");
    Set<String> result = listWithDuplicates.stream().collect(toSet());
    assertThat(result).hasSize(4);

#### Collectors.toCollection() ####

你可能已经注意到，使用toSet 和 toList收集器，不能指定其实现。如果想使用特定实现，需要使用toCollection收集器并提供特定集合实现。下面示例创建一个流实例表示元素序列，然后收集至LinkedList例对象中

List<String> result = givenList.stream().collect(toCollection(LinkedList::new))

注意这里不能使用不可变集合实现。通过自定义Collector实现或使用collectingAndThen。

#### Collectors.toMap() ####

ToMap 收集器用于收集流元素至 Map 实例，实现该功能需要提供两个函数:

*  keyMapper
 *  valueMapper

keyMapper 用于从流元素中抽取map 的key，valueMapper抽取与可以关联的value。  
下面示例收集流元素至Map中，存储字符串作为key，其长度作为value：

Map<String, Integer> result = givenList.stream()
      .collect(toMap(Function.identity(), String::length))

Function.identity() 是一个预定义的返回接收参数的快捷函数。  
如果我们集合中包含重复元素会怎么样？与toSet相反，toMap不能过滤重复元素。这个比较好理解————其如何确定key关联那个value？

List<String> listWithDuplicates = Arrays.asList("a", "bb", "c", "d", "bb");
    assertThatThrownBy(() -> {
        listWithDuplicates.stream().collect(toMap(Function.identity(), String::length));
    }).isInstanceOf(IllegalStateException.class);

我们看到，toMap甚至不判断值是否相等，如果key重复，立刻抛出IllegalStateException异常。当key冲突时，我们应该使用toMap的另一个重载方法：

Map<String, Integer> result = givenList.stream()
      .collect(toMap(Function.identity(), String::length, (item, identicalItem) -> item));

第三个参数是二元操作，我们可以指定如何处理key冲突。本例中我们可以任意选择一个，因为两者的长度始终一样。

#### Collectors.collectingAndThen() ####

CollectingAndThen 是一个特殊收集器，其可以收集完成后再结果上执行另外动作。下面收集流元素至List示例，然后转换结果为ImmutableList实例：

List<String> result = givenList.stream()
      .collect(collectingAndThen(toList(), ImmutableList::copyOf))

#### Collectors.joining() ####

Joining 收集器可以用于连接字符串流Stream中的元素。示例如下：

String result = givenList.stream()
      .collect(joining());

结果如下：

"abbcccdd"

还可以指定分隔符、前缀和后缀：

String result = givenList.stream()
      .collect(joining(" "));

结果如下：

"a bb ccc dd"

再看一个示例：

String result = givenList.stream()
      .collect(joining(" ", "PRE-", "-POST"));

结果为：

"PRE-a bb ccc dd-POST"

#### Collectors.counting() ####

Counting 是一个简单收集器，返回元素数量：

Long result = givenList.stream()
      .collect(counting());

#### Collectors.summarizingDouble/Long/Int() ####

SummarizingDouble/Long/Int 收集器返回流中抽取的数值元素的统计结果类型。下面示例获取字符串长度信息：

DoubleSummaryStatistics result = givenList.stream()
      .collect(summarizingDouble(String::length));

下面测试代码执行通过：

assertThat(result.getAverage()).isEqualTo(2);
    assertThat(result.getCount()).isEqualTo(4);
    assertThat(result.getMax()).isEqualTo(3);
    assertThat(result.getMin()).isEqualTo(1);
    assertThat(result.getSum()).isEqualTo(8);

#### Collectors.averagingDouble/Long/Int() ####

AveragingDouble/Long/Int 是返回流中抽取元素的平均值，下面示例计算字符串长度平均值：

Double result = givenList.stream()
      .collect(averagingDouble(String::length));

#### Collectors.summingDouble/Long/Int() ####

SummingDouble/Long/Int 返回抽取元素之和，下面计算所有字符串长度之和：

Double result = givenList.stream()
      .collect(summingDouble(String::length));

#### Collectors.maxBy()/minBy() ####

MaxBy/MinBy 收集器根据提供的 Comparator 实例，返回流中最大和最小元素，下面计算最大元素：

Optional<String> result = givenList.stream()
      .collect(maxBy(Comparator.naturalOrder()));

需要注意的是，其结果为Optional类型，其强制用户考虑空集合情况

#### Collectors.groupingBy() ####

分组收集器用于根据属性对元素进行分组并存储在Map实例中，下面示例根据字符串长度进行分组，并把结果存储在Set中：

Map<Integer, Set<String>> result = givenList.stream()
      .collect(groupingBy(String::length, toSet()));

测试代码如下：

assertThat(result)
      .containsEntry(1, newHashSet("a"))
      .containsEntry(2, newHashSet("bb", "dd"))
      .containsEntry(3, newHashSet("ccc"));

第二个参数是一个集合，我们开使用任何集合实现。

#### Collectors.partitioningBy() ####

PartitioningBy 是一个特殊分组收集器，依据 Predicate 实例收集流元素至Map中，存储 Boolean 值作为key，值为集合。 “true” 键对应值为已匹配元素的集合，“false” 键为非匹配元素集合。示例代码如下：

Map<Boolean, List<String>> result = givenList.stream()
      .collect(partitioningBy(s -> s.length() > 2))

结果Map如下：

{false=["a", "bb", "dd"], true=["ccc"]}

#### Collectors.teeing() ####

根据目前我们已经学习的内容求最大值和最小值：

List<Integer> numbers = Arrays.asList(42, 4, 2, 24);
    Optional<Integer> min = numbers.stream().collect(minBy(Integer::compareTo));
    Optional<Integer> max = numbers.stream().collect(maxBy(Integer::compareTo));
    // do something useful with min and max

这里，我们使用两个不用的收集器，然后合并集合去实现相应业务。在Java 12之前,为了实现这样功能必须对流执行两次操作，把中间结果存储至临时对象中，最后合并返回。  
幸运的是，java 12 提供了内置收集器帮助我们处理这些步骤：我们仅需提供两个收集器和合并函数。  
因为新的收集器tee对流执行两个不用方向的操作，故称为T收集器：

numbers.stream().collect(teeing(
      minBy(Integer::compareTo), // The first collector
      maxBy(Integer::compareTo), // The second collector
      (min, max) -> // Receives the result from those collectors and combines them
    ));

###  ###