Module java.base
Package java.util.stream

Class Collectors

java.lang.Object
java.util.stream.Collectors
public final class Collectors extends Object
实现了各种有用的减少操作的Collector，例如将元素累积到集合中，根据各种标准对元素进行总结等。

以下是使用预定义收集器执行常见可变减少任务的示例：


 // 将名称累积到列表中
 List<String> list = people.stream()
   .map(Person::getName)
   .collect(Collectors.toList());

 // 将名称累积到TreeSet中
 Set<String> set = people.stream()
   .map(Person::getName)
   .collect(Collectors.toCollection(TreeSet::new));

 // 将元素转换为字符串并用逗号分隔连接
 String joined = things.stream()
   .map(Object::toString)
   .collect(Collectors.joining(", "));

 // 计算员工薪水总和
 int total = employees.stream()
   .collect(Collectors.summingInt(Employee::getSalary));

 // 按部门对员工进行分组
 Map<Department, List<Employee>> byDept = employees.stream()
   .collect(Collectors.groupingBy(Employee::getDepartment));

 // 按部门计算薪水总和
 Map<Department, Integer> totalByDept = employees.stream()
   .collect(Collectors.groupingBy(Employee::getDepartment,
                                  Collectors.summingInt(Employee::getSalary)));

 // 将学生分为及格和不及格
 Map<Boolean, List<Student>> passingFailing = students.stream()
   .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));
自 JDK 版本:
1.8

  • Method Summary

    Modifier and Type
    Method
    Description
    static <T> Collector<T,?,Double>
    averagingDouble(ToDoubleFunction<? super T> mapper)
    返回一个Collector，该收集器生成应用于输入元素的双值函数的算术平均值。
    static <T> Collector<T,?,Double>
    averagingInt(ToIntFunction<? super T> mapper)
    返回一个Collector，该收集器生成应用于输入元素的整数值函数的算术平均值。
    static <T> Collector<T,?,Double>
    averagingLong(ToLongFunction<? super T> mapper)
    返回一个Collector，该收集器生成应用于输入元素的长整数值函数的算术平均值。
    static <T, A, R, RR>
    Collector<T,A,RR>
    collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)
    调整一个Collector以执行额外的完成转换。
    static <T> Collector<T,?,Long>
    counting()
    返回一个接受类型为T的元素并计算输入元素数量的Collector。
    static <T, A, R> Collector<T,?,R>
    filtering(Predicate<? super T> predicate, Collector<? super T,A,R> downstream)
    通过对每个输入元素应用谓词并仅在谓词返回true时累积，将一个接受相同类型T元素的Collector调整为另一个。
    static <T, U, A, R>
    Collector<T,?,R>
    flatMapping(Function<? super T,? extends Stream<? extends U>> mapper, Collector<? super U,A,R> downstream)
    通过在累积之前对每个输入元素应用平面映射函数，将一个接受类型为U的元素的Collector调整为接受类型为T的元素。
    static <T, K> Collector<T,?,Map<K,List<T>>>
    groupingBy(Function<? super T,? extends K> classifier)
    返回一个实现对类型为T的输入元素执行“分组”操作的Collector，根据分类函数对元素进行分组，并在Map中返回结果。
    static <T, K, D, A, M extends Map<K, D>>
    Collector<T,?,M>
    groupingBy(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)
    返回一个实现对类型为T的输入元素执行级联“分组”操作的Collector，根据分类函数对元素进行分组，然后使用指定的下游Collector对与给定键关联的值执行减少操作。
    static <T, K, A, D>
    Collector<T,?,Map<K,D>>
    groupingBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)
    返回一个实现对类型为T的输入元素执行级联“分组”操作的Collector，根据分类函数对元素进行分组，然后使用指定的下游Collector对与给定键关联的值执行减少操作。
    static <T, K> Collector<T,?,ConcurrentMap<K,List<T>>>
    groupingByConcurrent(Function<? super T,? extends K> classifier)
    返回一个并发Collector，该收集器在类型为T的输入元素上执行“分组”操作，根据分类函数对元素进行分组。
    static <T, K, A, D, M extends ConcurrentMap<K, D>>
    Collector<T,?,M>
    groupingByConcurrent(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)
    返回一个并发Collector，该收集器在类型为T的输入元素上执行级联“分组”操作，根据分类函数对元素进行分组，然后使用指定的下游Collector对与给定键关联的值执行减少操作。
    static <T, K, A, D>
    Collector<T,?,ConcurrentMap<K,D>>
    groupingByConcurrent(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)
    返回一个并发Collector，该收集器在类型为T的输入元素上执行级联“分组”操作，根据分类函数对元素进行分组，然后使用指定的下游Collector对与给定键关联的值执行减少操作。
    static Collector<CharSequence,?,String>
    joining()
    返回一个Collector，将输入元素按照出现顺序连接为String。
    static Collector<CharSequence,?,String>
    joining(CharSequence delimiter)
    返回一个Collector，将输入元素按指定分隔符分隔并按出现顺序连接。
    static Collector<CharSequence,?,String>
    joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
    返回一个Collector，将输入元素按指定分隔符分隔，并在出现顺序中使用指定的前缀和后缀连接。
    static <T, U, A, R>
    Collector<T,?,R>
    mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)
    通过在累积之前对每个输入元素应用映射函数，将一个接受类型为U的元素的Collector调整为接受类型为T的元素。
    static <T> Collector<T,?,Optional<T>>
    maxBy(Comparator<? super T> comparator)
    返回一个Collector，根据给定的Comparator产生最大元素，描述为Optional<T>。
    static <T> Collector<T,?,Optional<T>>
    minBy(Comparator<? super T> comparator)
    返回一个Collector，根据给定的Comparator产生最小元素，描述为Optional<T>。
    static <T> Collector<T,?,Map<Boolean,List<T>>>
    partitioningBy(Predicate<? super T> predicate)
    返回一个Collector，根据Predicate对输入元素进行分区，并将它们组织成Map<Boolean, List<T>>。
    static <T, D, A> Collector<T,?,Map<Boolean,D>>
    partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
    返回一个Collector，根据Predicate对输入元素进行分区，根据另一个Collector对每个分区中的值进行减少，并将它们组织成Map<Boolean, D>，其值是下游减少的结果。
    static <T> Collector<T,?,Optional<T>>
    reducing(BinaryOperator<T> op)
    返回一个Collector，在指定的BinaryOperator下对其输入元素进行减少。
    static <T> Collector<T,?,T>
    reducing(T identity, BinaryOperator<T> op)
    返回一个Collector，在指定的BinaryOperator和提供的标识下对其输入元素进行减少。
    static <T, U> Collector<T,?,U>
    reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op)
    返回一个Collector，在指定的映射函数和BinaryOperator下对其输入元素进行减少。
    static <T> Collector<T,?,DoubleSummaryStatistics>
    summarizingDouble(ToDoubleFunction<? super T> mapper)
    返回一个Collector，将double生成的映射函数应用于每个输入元素，并返回结果值的摘要统计信息。
    static <T> Collector<T,?,IntSummaryStatistics>
    summarizingInt(ToIntFunction<? super T> mapper)
    返回一个Collector，将int生成的映射函数应用于每个输入元素，并返回结果值的摘要统计信息。
    static <T> Collector<T,?,LongSummaryStatistics>
    summarizingLong(ToLongFunction<? super T> mapper)
    返回一个Collector，将long生成的映射函数应用于每个输入元素，并返回结果值的摘要统计信息。
    static <T> Collector<T,?,Double>
    summingDouble(ToDoubleFunction<? super T> mapper)
    返回一个Collector，产生应用于输入元素的双值函数的总和。
    static <T> Collector<T,?,Integer>
    summingInt(ToIntFunction<? super T> mapper)
    返回一个Collector，产生应用于输入元素的整数值函数的总和。
    static <T> Collector<T,?,Long>
    summingLong(ToLongFunction<? super T> mapper)
    返回一个Collector，产生应用于输入元素的长整数值函数的总和。
    static <T, R1, R2, R>
    Collector<T,?,R>
    teeing(Collector<? super T,?,R1> downstream1, Collector<? super T,?,R2> downstream2, BiFunction<? super R1,? super R2,R> merger)
    返回一个由两个下游收集器组成的复合Collector。
    static <T, C extends Collection<T>>
    Collector<T,?,C>
    toCollection(Supplier<C> collectionFactory)
    返回一个Collector，按出现顺序将输入元素累积到新的Collection中。
    static <T, K, U> Collector<T,?,ConcurrentMap<K,U>>
    toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
    返回一个并发Collector，将元素累积到ConcurrentMap中，其键和值是将提供的映射函数应用于输入元素的结果。
    static <T, K, U> Collector<T,?,ConcurrentMap<K,U>>
    toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)
    返回一个并发Collector，将元素累积到ConcurrentMap中，其键和值是将提供的映射函数应用于输入元素的结果。
    static <T, K, U, M extends ConcurrentMap<K, U>>
    Collector<T,?,M>
    toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapFactory)
    返回一个并发Collector，将元素累积到ConcurrentMap中，其键和值是将提供的映射函数应用于输入元素的结果。
    static <T> Collector<T,?,List<T>>
    toList()
    返回一个Collector，将输入元素累积到新的List中。
    static <T, K, U> Collector<T,?,Map<K,U>>
    toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
    返回一个Collector，将元素累积到Map中，其键和值是将提供的映射函数应用于输入元素的结果。
    static <T, K, U> Collector<T,?,Map<K,U>>
    toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)
    返回一个Collector，将元素累积到Map中，其键和值是将提供的映射函数应用于输入元素的结果。
    static <T, K, U, M extends Map<K, U>>
    Collector<T,?,M>
    toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapFactory)
    返回一个Collector，将元素累积到Map中，其键和值是将提供的映射函数应用于输入元素的结果。
    static <T> Collector<T,?,Set<T>>
    toSet()
    返回一个Collector，将输入元素累积到新的Set中。
    static <T> Collector<T,?,List<T>>
    toUnmodifiableList()
    返回一个Collector，将输入元素按出现顺序累积到不可修改的列表中。
    static <T, K, U> Collector<T,?,Map<K,U>>
    toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
    返回一个Collector，将输入元素累积到不可修改的Map中，其键和值是将提供的映射函数应用于输入元素的结果。
    static <T, K, U> Collector<T,?,Map<K,U>>
    toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)
    返回一个Collector，将输入元素累积到不可修改的Map中，其键和值是将提供的映射函数应用于输入元素的结果。
    static <T> Collector<T,?,Set<T>>
    toUnmodifiableSet()
    返回一个Collector，将输入元素累积到不可修改的Set中。

    Methods declared in class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Method Details

    • toCollection

      public static <T, C extends Collection<T>> Collector<T,?,C> toCollection(Supplier<C> collectionFactory)
      返回一个Collector，按出现顺序将输入元素累积到新的Collection中。由提供的工厂创建Collection。
      类型参数:
      T - 输入元素的类型
      C - 结果Collection的类型
      参数:
      collectionFactory - 提供新的空Collection的供应商，结果将插入其中
      返回:
      一个Collector，将所有输入元素按出现顺序收集到Collection中

    • toList

      public static <T> Collector<T,?,List<T>> toList()
      返回一个Collector，将输入元素累积到新的List中。对返回的List的类型、可变性、可序列化性或线程安全性没有保证；如果需要更多对返回List的控制，请使用toCollection(Supplier)。
      类型参数:
      T - 输入元素的类型
      返回:
      一个Collector，将所有输入元素按照出现顺序收集到一个List中

    • toUnmodifiableList

      public static <T> Collector<T,?,List<T>> toUnmodifiableList()
      返回一个Collector，将输入元素按照出现顺序累积到一个不可修改的List中。返回的Collector不允许空值，如果出现空值将抛出NullPointerException。
      类型参数:
      T - 输入元素的类型
      返回:
      一个Collector，将输入元素按照出现顺序累积到一个不可修改的List中
      自 JDK 版本:
      10

    • toSet

      public static <T> Collector<T,?,Set<T>> toSet()
      返回一个Collector，将输入元素累积到一个新的Set中。对于返回的Set，不保证其类型、可变性、可序列化性或线程安全性；如果需要更多对返回的Set的控制，请使用toCollection(Supplier)。

      这是一个无序的Collector。

      类型参数:
      T - 输入元素的类型
      返回:
      一个Collector，将所有输入元素收集到一个Set中

    • toUnmodifiableSet

      public static <T> Collector<T,?,Set<T>> toUnmodifiableSet()
      返回一个Collector，将输入元素累积到一个不可修改的Set中。返回的Collector不允许空值，如果出现空值将抛出NullPointerException。如果输入包含重复元素，则保留重复元素中的任意一个。

      这是一个无序的Collector。

      类型参数:
      T - 输入元素的类型
      返回:
      一个Collector，将输入元素累积到一个不可修改的Set中
      自 JDK 版本:
      10

    • joining

      public static Collector<CharSequence,?,String> joining()
      返回一个Collector，将输入元素按照出现顺序连接成一个String。
      返回:
      一个Collector，将输入元素按照出现顺序连接成一个String

    • joining

      public static Collector<CharSequence,?,String> joining(CharSequence delimiter)
      返回一个Collector，将输入元素按照指定的分隔符分隔后按照出现顺序连接。
      参数:
      delimiter - 每个元素之间要使用的分隔符
      返回:
      一个Collector，将CharSequence元素按照指定的分隔符分隔后按照出现顺序连接

    • joining

      public static Collector<CharSequence,?,String> joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
      返回一个Collector，将输入元素按照指定的分隔符分隔并在出现顺序中添加指定的前缀和后缀。
      参数:
      delimiter - 每个元素之间要使用的分隔符
      prefix - 要在连接结果开头使用的字符序列
      suffix - 要在连接结果结尾使用的字符序列
      返回:
      一个Collector，将CharSequence元素按照指定的分隔符分隔后按照出现顺序连接

    • mapping

      public static <T, U, A, R> Collector<T,?,R> mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)
      将接受类型为U的元素的Collector通过对每个输入元素应用映射函数进行累积，转换为接受类型为T的元素的Collector。
      API 注释:
      当在多级减少操作中使用时，mapping()收集器最有用，例如在groupingBy或partitioningBy的下游。例如，给定一个Person流，要在每个城市中累积姓氏的集合： 
      
 Map<City, Set<String>> lastNamesByCity
   = people.stream().collect(
     groupingBy(Person::getCity,
                mapping(Person::getLastName,
                        toSet())));
      类型参数:
      T - 输入元素的类型
      U - 下游收集器接受的元素类型
      A - 下游收集器的中间累积类型
      R - 收集器的结果类型
      参数:
      mapper - 要应用于输入元素的函数
      downstream - 将接受映射值的收集器
      返回:
      一个收集器，将映射函数应用于输入元素，并将映射结果提供给下游收集器

    • flatMapping

      public static <T, U, A, R> Collector<T,?,R> flatMapping(Function<? super T,? extends Stream<? extends U>> mapper, Collector<? super U,A,R> downstream)
      将接受类型为U的元素的Collector通过对每个输入元素应用扁平映射函数进行累积，转换为接受类型为T的元素的Collector。扁平映射函数将一个输入元素映射到一个包含零个或多个输出元素的stream，然后将这些元素在下游进行累积。每个映射的流在其内容被放置到下游后会被关闭。（如果映射的流为null，则使用空流代替。）
      API 注释:
      当在多级减少操作中使用时，flatMapping()收集器最有用，例如在groupingBy或partitioningBy的下游。例如，给定一个Order流，要在每个客户的订单中累积行项目的集合： 
      
 Map<String, Set<LineItem>> itemsByCustomerName
   = orders.stream().collect(
     groupingBy(Order::getCustomerName,
                flatMapping(order -> order.getLineItems().stream(),
                            toSet())));
      类型参数:
      T - 输入元素的类型
      U - 下游收集器接受的元素类型
      A - 下游收集器的中间累积类型
      R - 收集器的结果类型
      参数:
      mapper - 要应用于输入元素的函数，返回结果流
      downstream - 将接收映射流元素的收集器
      返回:
      一个收集器，将映射函数应用于输入元素，并将扁平映射结果提供给下游收集器
      自 JDK 版本:
      9

    • filtering

      public static <T, A, R> Collector<T,?,R> filtering(Predicate<? super T> predicate, Collector<? super T,A,R> downstream)
      将一个接受类型为T的元素的Collector通过对每个输入元素应用谓词，仅在谓词返回true时进行累积，转换为一个接受相同类型T的元素的Collector。
      API 注释:
      当在多级减少操作中使用时，filtering()收集器最有用，例如在groupingBy或partitioningBy的下游。例如，给定一个Employee流，要在每个部门中累积工资高于某一阈值的员工： 
      
 Map<Department, Set<Employee>> wellPaidEmployeesByDepartment
   = employees.stream().collect(
     groupingBy(Employee::getDepartment,
                filtering(e -> e.getSalary() > 2000,
                          toSet())));
      过滤收集器与流的filter()操作不同。在这个例子中，假设某个部门没有工资高于阈值的员工。使用上述方式的过滤收集器将导致该部门映射到一个空的Set。如果使用流的filter()操作，那么该部门将根本没有映射。
      类型参数:
      T - 输入元素的类型
      A - 下游收集器的中间累积类型
      R - 收集器的结果类型
      参数:
      predicate - 要应用于输入元素的谓词
      downstream - 将接收与谓词匹配值的收集器
      返回:
      一个收集器，将谓词应用于输入元素，并将匹配的元素提供给下游收集器
      自 JDK 版本:
      9

    • collectingAndThen

      public static <T, A, R, RR> Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)
      将一个Collector适配为接受相同类型T的元素并执行额外的完成转换。例如，可以将toList()收集器适配为始终生成一个不可变列表： 
      
 List<String> list = people.stream().collect(
   collectingAndThen(toList(),
                     Collections::unmodifiableList));
      类型参数:
      T - 输入元素的类型
      A - 下游收集器的中间累积类型
      R - 下游收集器的结果类型
      RR - 结果收集器的结果类型
      参数:
      downstream - 一个收集器
      finisher - 要应用于下游收集器的最终结果的函数
      返回:
      一个收集器，执行下游收集器的操作，然后进行额外的完成步骤

    • counting

      public static <T> Collector<T,?,Long> counting()
      返回一个接受类型为T的元素并计算输入元素数量的Collector。如果没有元素存在，则结果为0。
      实现要求:
      这将产生与以下等效的结果： 
      
     reducing(0L, e -> 1L, Long::sum)
      类型参数:
      T - 输入元素的类型
      返回:
      一个Collector，用于计算输入元素的数量

    • minBy

      public static <T> Collector<T,?,Optional<T>> minBy(Comparator<? super T> comparator)
      返回一个根据给定Comparator产生最小元素的Collector，描述为Optional<T>。
      实现要求:
      这将产生与以下等效的结果： 
      
     reducing(BinaryOperator.minBy(comparator))
      类型参数:
      T - 输入元素的类型
      参数:
      comparator - 用于比较元素的Comparator
      返回:
      一个Collector，产生最小值

    • maxBy

      public static <T> Collector<T,?,Optional<T>> maxBy(Comparator<? super T> comparator)
      返回一个Collector，根据给定的Comparator生成最大元素，描述为Optional<T>。
      实现要求:
      这将产生一个等效于: 
      
     reducing(BinaryOperator.maxBy(comparator))
      类型参数:
      T - 输入元素的类型
      参数:
      comparator - 用于比较元素的Comparator
      返回:
      产生最大值的Collector

    • summingInt

      public static <T> Collector<T,?,Integer> summingInt(ToIntFunction<? super T> mapper)
      返回一个Collector，生成应用于输入元素的整数值函数的总和。如果没有元素存在，则结果为0。
      类型参数:
      T - 输入元素的类型
      参数:
      mapper - 用于提取要求和的属性的函数
      返回:
      产生派生属性总和的Collector

    • summingLong

      public static <T> Collector<T,?,Long> summingLong(ToLongFunction<? super T> mapper)
      返回一个Collector，生成应用于输入元素的长整型值函数的总和。如果没有元素存在，则结果为0。
      类型参数:
      T - 输入元素的类型
      参数:
      mapper - 用于提取要求和的属性的函数
      返回:
      产生派生属性总和的Collector

    • summingDouble

      public static <T> Collector<T,?,Double> summingDouble(ToDoubleFunction<? super T> mapper)
      返回一个Collector，生成应用于输入元素的双精度值函数的总和。如果没有元素存在，则结果为0。

      返回的总和可能会因记录值的顺序而变化，这是由于在不同数量级的值相加时累积的舍入误差。按绝对值递增排序的值往往会产生更准确的结果。如果任何记录的值是NaN，或者总和在任何时候是NaN，则总和将是NaN。

      类型参数:
      T - 输入元素的类型
      参数:
      mapper - 用于提取要求和的属性的函数
      返回:
      产生派生属性总和的Collector

    • averagingInt

      public static <T> Collector<T,?,Double> averagingInt(ToIntFunction<? super T> mapper)
      返回一个Collector，生成应用于输入元素的整数值函数的算术平均值。如果没有元素存在，则结果为0。
      类型参数:
      T - 输入元素的类型
      参数:
      mapper - 用于提取要求平均值的属性的函数
      返回:
      产生派生属性算术平均值的Collector

    • averagingLong

      public static <T> Collector<T,?,Double> averagingLong(ToLongFunction<? super T> mapper)
      返回一个Collector，生成应用于输入元素的长整型值函数的算术平均值。如果没有元素存在，则结果为0。
      类型参数:
      T - 输入元素的类型
      参数:
      mapper - 用于提取要求平均值的属性的函数
      返回:
      产生派生属性算术平均值的Collector

    • averagingDouble

      public static <T> Collector<T,?,Double> averagingDouble(ToDoubleFunction<? super T> mapper)
      返回一个Collector，生成应用于输入元素的双精度值函数的算术平均值。如果没有元素存在，则结果为0。

      返回的平均值可能会因记录值的顺序而变化，这是由于在不同数量级的值相加时累积的舍入误差。按绝对值递增排序的值往往会产生更准确的结果。如果任何记录的值是NaN，或者总和在任何时候是NaN，则平均值将是NaN。

      实现注意:
      double 格式可以表示范围在 -253 到 253 之间的所有连续整数。如果管道中的值超过 253 个，平均值计算中的除数将饱和为 253，导致额外的数值误差。
      类型参数:
      T - 输入元素的类型
      参数:
      mapper - 用于提取要求平均值的属性的函数
      返回:
      产生派生属性算术平均值的Collector

    • reducing

      public static <T> Collector<T,?,T> reducing(T identity, BinaryOperator<T> op)
      返回一个Collector，使用提供的标识对其输入元素进行指定的BinaryOperator 归约。
      API 注意:
      当在多级归约中使用时，reducing() 收集器在groupingBy或partitioningBy的下游时最有用。要在流上执行简单的归约，请使用Stream.reduce(Object, BinaryOperator)。
      类型参数:
      T - 归约的输入和输出元素类型
      参数:
      identity - 归约的标识值（也是没有输入元素时返回的值）
      op - 用于归约输入元素的BinaryOperator<T>
      返回:
      实现归约操作的Collector
      参见:

    • reducing

      public static <T> Collector<T,?,Optional<T>> reducing(BinaryOperator<T> op)
      返回一个Collector，在指定的BinaryOperator 下对其输入元素执行归约。结果描述为Optional<T>。
      API 注意:
      当在多级归约中使用时，reducing() 收集器在groupingBy或partitioningBy的下游时最有用。要在流上执行简单的归约，请使用Stream.reduce(BinaryOperator)。

      例如，给定一个Person流，计算每个城市中最高的人:

      
 Comparator<Person> byHeight = Comparator.comparing(Person::getHeight);
 Map<City, Optional<Person>> tallestByCity
   = people.stream().collect(
     groupingBy(Person::getCity,
                reducing(BinaryOperator.maxBy(byHeight))));
      类型参数:
      T - 归约的输入和输出元素类型
      参数:
      op - 用于归约输入元素的BinaryOperator<T>
      返回:
      实现归约操作的Collector
      参见:

    • reducing

      public static <T, U> Collector<T,?,U> reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op)
      返回一个Collector，在指定的映射函数和BinaryOperator 下对其输入元素执行归约。这是reducing(Object, BinaryOperator)的泛化，允许在归约之前对元素进行转换。
      API 注意:
      当在多级归约中使用时，reducing() 收集器在groupingBy或partitioningBy的下游时最有用。要在流上执行简单的映射-归约，请使用Stream.map(Function)和Stream.reduce(Object, BinaryOperator)。

      例如，给定一个Person流，计算每个城市中居民的最长姓氏:

      
 Comparator<String> byLength = Comparator.comparing(String::length);
 Map<City, String> longestLastNameByCity
   = people.stream().collect(
     groupingBy(Person::getCity,
                reducing("",
                         Person::getLastName,
                         BinaryOperator.maxBy(byLength))));
      类型参数:
      T - 输入元素的类型
      U - 映射值的类型
      参数:
      identity - 归约的标识值（也是没有输入元素时返回的值）
      mapper - 应用于每个输入值的映射函数
      op - 用于归约映射值的BinaryOperator<U>
      返回:
      实现映射-归约操作的Collector
      参见:

    • groupingBy

      public static <T, K> Collector<T,?,Map<K,List<T>>> groupingBy(Function<? super T,? extends K> classifier)
      返回一个Collector，在类型为T的输入元素上执行“分组”操作，根据分类函数对元素进行分组，并将结果返回为Map。

      分类函数将元素映射到某个键类型K。收集器生成一个Map<K, List<T>>，其键是将分类函数应用于输入元素产生的值，其相应的值是包含将输入元素映射到分类函数下关联键的List。

      对于返回的Map或List对象的类型、可变性、可序列化性或线程安全性没有保证。

      实现要求:
      这会产生类似于: 
      
     groupingBy(classifier, toList());
      实现说明:
      返回的Collector不是并发的。对于并行流水线，combiner函数通过将一个映射中的键合并到另一个映射中来操作，这可能是一个昂贵的操作。如果不需要保留元素在生成的Map中出现的顺序，使用groupingByConcurrent(Function)可能会提供更好的并行性能。
      类型参数:
      T - 输入元素的类型
      K - 键的类型
      参数:
      classifier - 将输入元素映射到键的分类函数
      返回:
      实现分组操作的Collector
      参见:

    • groupingBy

      public static <T, K, A, D> Collector<T,?,Map<K,D>> groupingBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)
      返回一个实现对输入元素进行级联“分组”的Collector，根据分类函数对元素进行分组，然后使用指定的下游Collector对与给定键关联的值执行归约操作。

      分类函数将元素映射到某个键类型K。下游收集器操作T类型的元素，并产生D类型的结果。生成的收集器产生一个Map<K, D>。

      对返回的Map的类型、可变性、可序列化性或线程安全性没有保证。

      例如，计算每个城市中人员姓氏的集合:

      
 Map<City, Set<String>> namesByCity
   = people.stream().collect(
     groupingBy(Person::getCity,
                mapping(Person::getLastName,
                        toSet())));
      实现说明:
      返回的Collector不是并发的。对于并行流水线，combiner函数通过将一个映射中的键合并到另一个映射中来操作，这可能是一个昂贵的操作。如果不需要保留元素被呈现给下游收集器的顺序，使用groupingByConcurrent(Function, Collector)可能会提供更好的并行性能。
      类型参数:
      T - 输入元素的类型
      K - 键的类型
      A - 下游收集器的中间累积类型
      D - 下游归约的结果类型
      参数:
      classifier - 将输入元素映射到键的分类函数
      downstream - 实现下游归约的Collector
      返回:
      实现级联分组操作的Collector
      参见:

    • groupingBy

      public static <T, K, D, A, M extends Map<K, D>> Collector<T,?,M> groupingBy(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)
      返回一个实现对输入元素进行级联“分组”的Collector，根据分类函数对元素进行分组，然后使用指定的下游Collector对与给定键关联的值执行归约操作。由提供的工厂函数创建收集器生成的Map。

      分类函数将元素映射到某个键类型K。下游收集器操作T类型的元素，并产生D类型的结果。生成的收集器产生一个Map<K, D>。

      对返回的Map的类型、可变性、可序列化性或线程安全性没有保证。

      例如，计算每个城市中人员姓氏的集合，其中城市名称已排序:

      
 Map<City, Set<String>> namesByCity
   = people.stream().collect(
     groupingBy(Person::getCity,
                TreeMap::new,
                mapping(Person::getLastName,
                        toSet())));
      实现说明:
      返回的Collector不是并发的。对于并行流水线，combiner函数通过将一个映射中的键合并到另一个映射中来操作，这可能是一个昂贵的操作。如果不需要保留元素被呈现给下游收集器的顺序，使用groupingByConcurrent(Function, Supplier, Collector)可能会提供更好的并行性能。
      类型参数:
      T - 输入元素的类型
      K - 键的类型
      D - 下游归约的结果类型
      A - 下游收集器的中间累积类型
      M - 结果Map的类型
      参数:
      classifier - 将输入元素映射到键的分类函数
      mapFactory - 提供一个新的空Map的供应商，用于插入结果
      downstream - 实现下游归约的Collector
      返回:
      实现级联分组操作的Collector
      参见:

    • groupingByConcurrent

      public static <T, K> Collector<T,?,ConcurrentMap<K,List<T>>> groupingByConcurrent(Function<? super T,? extends K> classifier)
      返回一个并发的Collector，实现对输入元素进行“分组”操作，根据分类函数对元素进行分组。

      这是一个并发和无序的收集器。

      分类函数将元素映射到某个键类型K。收集器产生一个ConcurrentMap<K, List<T>>，其键是将分类函数应用于输入元素产生的值，对应的值是包含将输入元素映射到相关键下的List的列表。

      对返回的ConcurrentMap或List对象的类型、可变性或可序列化性，以及返回的List对象的线程安全性没有保证。

      实现要求:
      这会产生类似于: 
      
     groupingByConcurrent(classifier, toList());
      类型参数:
      T - 输入元素的类型
      K - 键的类型
      参数:
      classifier - 将输入元素映射到键的分类函数
      返回:
      一个并发的、无序的Collector，实现分组操作
      参见:

    • groupingByConcurrent

      public static <T, K, A, D> Collector<T,?,ConcurrentMap<K,D>> groupingByConcurrent(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)
      返回一个并发的Collector，实现对输入元素进行级联“分组”的操作，根据分类函数对元素进行分组，然后使用指定的下游Collector对与给定键关联的值执行归约操作。

      这是一个并发和无序的收集器。

      分类函数将元素映射到某个键类型K。下游收集器操作T类型的元素，并产生D类型的结果。生成的收集器产生一个ConcurrentMap<K, D>。

      对返回的ConcurrentMap的类型、可变性或可序列化性没有保证。

      例如，计算每个城市中人员姓氏的集合，其中城市名称已排序:

      
 ConcurrentMap<City, Set<String>> namesByCity
   = people.stream().collect(
     groupingByConcurrent(Person::getCity,
                          mapping(Person::getLastName,
                                  toSet())));
      类型参数:
      T - 输入元素的类型
      K - 键的类型
      A - 下游收集器的中间累积类型
      D - 下游规约的结果类型
      参数:
      classifier - 将输入元素映射到键的分类器函数
      downstream - 实现下游规约的Collector
      返回:
      一个并发的、无序的Collector，实现级联的分组操作
      参见:

    • groupingByConcurrent

      public static <T, K, A, D, M extends ConcurrentMap<K, D>> Collector<T,?,M> groupingByConcurrent(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)
      返回一个并发的Collector，实现对类型为T的输入元素进行级联的“分组”操作，根据分类函数对元素进行分组，然后使用指定的下游Collector对与给定键关联的值执行规约操作。由收集器生成的ConcurrentMap是使用提供的工厂函数创建的。

      这是一个并发且无序的收集器。

      分类函数将元素映射到某个键类型K。下游收集器操作类型为T的元素，并产生类型为D的结果。生成的收集器产生一个ConcurrentMap<K, D>。

      例如，要计算每个城市中人的姓氏集合，其中城市名称已排序：

      
 ConcurrentMap<City, Set<String>> namesByCity
   = people.stream().collect(
     groupingByConcurrent(Person::getCity,
                          ConcurrentSkipListMap::new,
                          mapping(Person::getLastName,
                                  toSet())));
      类型参数:
      T - 输入元素的类型
      K - 键的类型
      A - 下游收集器的中间累积类型
      D - 下游规约的结果类型
      M - 结果ConcurrentMap的类型
      参数:
      classifier - 将输入元素映射到键的分类器函数
      mapFactory - 提供新的空ConcurrentMap的供应商，结果将插入其中
      downstream - 实现下游规约的Collector
      返回:
      一个并发的、无序的Collector，实现级联的分组操作
      参见:

    • partitioningBy

      public static <T> Collector<T,?,Map<Boolean,List<T>>> partitioningBy(Predicate<? super T> predicate)
      返回一个Collector，根据Predicate将输入元素进行分区，并将它们组织成Map<Boolean, List<T>>。返回的Map始终包含false和true键的映射。对于返回的Map的类型、可变性、可序列化性或线程安全性没有保证。
      API 注意:
      如果一个分区没有元素，其在结果Map中的值将是一个空列表。
      类型参数:
      T - 输入元素的类型
      参数:
      predicate - 用于对输入元素进行分类的谓词
      返回:
      一个实现分区操作的Collector
      参见:

    • partitioningBy

      public static <T, D, A> Collector<T,?,Map<Boolean,D>> partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
      返回一个Collector，根据Predicate将输入元素进行分区，根据另一个Collector对每个分区中的值进行规约，并将它们组织成Map<Boolean, D>，其值是下游规约的结果。

      返回的Map始终包含false和true键的映射。对于返回的Map的类型、可变性、可序列化性或线程安全性没有保证。

      API 注意:
      如果一个分区没有元素，其在结果Map中的值将通过调用下游收集器的供应商函数获得，然后应用完成器函数。
      类型参数:
      T - 输入元素的类型
      D - 下游规约的结果类型
      A - 下游收集器的中间累积类型
      参数:
      predicate - 用于对输入元素进行分类的谓词
      downstream - 实现下游规约的Collector
      返回:
      一个实现级联分区操作的Collector
      参见:

    • toMap

      public static <T, K, U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
      返回一个Collector，将元素累积到一个Map中，其键和值是将提供的映射函数应用于输入元素的结果。

      如果映射的键包含重复项（根据Object.equals(Object)），则在执行收集操作时将抛出IllegalStateException。如果映射的键可能包含重复项，请改用toMap(Function, Function, BinaryOperator)。

      对于返回的Map的类型、可变性、可序列化性或线程安全性没有保证。

      API 注意:
      在键或值为输入元素的情况下很常见。在这种情况下，实用方法Function.identity()可能会有所帮助。例如，以下代码生成将学生映射到他们的平均绩点的Map： 
      
 Map<Student, Double> studentToGPA
   = students.stream().collect(
     toMap(Function.identity(),
           student -> computeGPA(student)));
      以下代码生成将唯一标识符映射到学生的Map： 
      
 Map<String, Student> studentIdToStudent
   = students.stream().collect(
     toMap(Student::getId,
           Function.identity()));
      实现注意:
      返回的Collector不是并发的。对于并行流管道，combiner函数通过将一个Map的键合并到另一个Map中来操作，这可能是一个昂贵的操作。如果不要求结果按照遇到的顺序插入到Map中，使用toConcurrentMap(Function, Function)可能会提供更好的并行性能。
      类型参数:
      T - 输入元素的类型
      K - 键映射函数的输出类型
      U - 值映射函数的输出类型
      参数:
      keyMapper - 生成键的映射函数
      valueMapper - 生成值的映射函数
      返回:
      一个Collector，将元素收集到一个Map中，其键和值是将映射函数应用于输入元素的结果
      参见:

    • toUnmodifiableMap

      public static <T, K, U> Collector<T,?,Map<K,U>> toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
      返回一个Collector，将输入元素累积到一个不可修改的Map中，其键和值是将提供的映射函数应用于输入元素的结果。

      如果映射的键包含重复项（根据Object.equals(Object)），则在执行收集操作时将抛出IllegalStateException。如果映射的键可能包含重复项，请使用toUnmodifiableMap(Function, Function, BinaryOperator)来处理值的合并。

      返回的收集器不允许空键和值。如果任一映射函数返回null，则将抛出NullPointerException。

      类型参数:
      T - 输入元素的类型
      K - 键映射函数的输出类型
      U - 值映射函数的输出类型
      参数:
      keyMapper - 用于生成键的映射函数，必须非空
      valueMapper - 用于生成值的映射函数，必须非空
      返回:
      一个Collector，将输入元素累积到一个unmodifiable Map中，其键和值是将提供的映射函数应用于输入元素的结果
      抛出:
      NullPointerException - 如果keyMapper或valueMapper为null
      自版本:
      10
      参见:

    • toMap

      public static <T, K, U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)
      返回一个Collector，将元素累积到一个Map中，其键和值是将提供的映射函数应用于输入元素的结果。

      如果映射的键包含重复项（根据Object.equals(Object)），则将值映射函数应用于每个相等的元素，并使用提供的合并函数合并结果。

      对于返回的Map，不保证其类型、可变性、可序列化性或线程安全性。

      API注释:
      处理多个元素映射到相同键之间的冲突有多种方法。其他形式的toMap简单地使用一个无条件抛出异常的合并函数，但您可以轻松编写更灵活的合并策略。例如，如果您有一个Person流，想要生成一个将姓名映射到地址的“电话簿”，但可能有两个人有相同的姓名，您可以按照以下方式优雅地处理这些冲突，并生成一个将姓名映射到地址列表的Map： 
      
 Map<String, String> phoneBook
   = people.stream().collect(
     toMap(Person::getName,
           Person::getAddress,
           (s, a) -> s + ", " + a));
      实现注释:
      返回的Collector不是并发的。对于并行流管道，combiner函数通过将一个映射中的键合并到另一个映射中来操作，这可能是一个昂贵的操作。如果不要求结果按照遇到的顺序合并到Map中，则使用toConcurrentMap(Function, Function, BinaryOperator)可能提供更好的并行性能。
      类型参数:
      T - 输入元素的类型
      K - 键映射函数的输出类型
      U - 值映射函数的输出类型
      参数:
      keyMapper - 用于生成键的映射函数
      valueMapper - 用于生成值的映射函数
      mergeFunction - 一个合并函数，用于解决与相同键关联的值之间的冲突，作为提供给Map.merge(Object, Object, BiFunction)的参数
      返回:
      一个Collector，将元素收集到一个Map中，其键是将键映射函数应用于输入元素的结果，值是将值映射函数应用于所有等于键的输入元素的结果，并使用合并函数将它们组合起来
      参见:

    • toUnmodifiableMap

      public static <T, K, U> Collector<T,?,Map<K,U>> toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)
      返回一个Collector，将输入元素累积到一个unmodifiable Map中，其键和值是将提供的映射函数应用于输入元素的结果。

      如果映射的键包含重复项（根据Object.equals(Object)），则将值映射函数应用于每个相等的元素，并使用提供的合并函数合并结果。

      返回的Collector不允许空键和值。如果任一映射函数返回null，则将抛出NullPointerException。

      类型参数:
      T - 输入元素的类型
      K - 键映射函数的输出类型
      U - 值映射函数的输出类型
      参数:
      keyMapper - 用于生成键的映射函数，必须非空
      valueMapper - 用于生成值的映射函数，必须非空
      mergeFunction - 一个合并函数，用于解决与相同键关联的值之间的冲突，作为提供给Map.merge(Object, Object, BiFunction)的参数，必须非空
      返回:
      一个Collector，将输入元素累积到一个unmodifiable Map中，其键和值是将提供的映射函数应用于输入元素的结果
      抛出:
      NullPointerException - 如果keyMapper、valueMapper或mergeFunction为null
      自版本:
      10
      参见:

    • toMap

      public static <T, K, U, M extends Map<K, U>> Collector<T,?,M> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapFactory)
      返回一个Collector，将元素累积到一个Map中，其键和值是将提供的映射函数应用于输入元素的结果。

      如果映射的键包含重复项（根据Object.equals(Object)），则将值映射函数应用于每个相等的元素，并使用提供的合并函数合并结果。Map由提供的供应商函数创建。

      实现注释:
      返回的Collector不是并发的。对于并行流管道，combiner函数通过将一个映射中的键合并到另一个映射中来操作，这可能是一个昂贵的操作。如果不要求结果按照遇到的顺序合并到Map中，则使用toConcurrentMap(Function, Function, BinaryOperator, Supplier)可能提供更好的并行性能。
      类型参数:
      T - 输入元素的类型
      K - 键映射函数的输出类型
      U - 值映射函数的输出类型
      M - 结果Map的类型
      参数:
      keyMapper - 用于生成键的映射函数
      valueMapper - 用于生成值的映射函数
      mergeFunction - 一个合并函数，用于解决与相同键关联的值之间的冲突，作为提供给Map.merge(Object, Object, BiFunction)的参数
      mapFactory - 一个提供新的空Map的供应商函数，结果将被插入其中
      返回:
      一个Collector，将元素收集到一个Map中，其键是将键映射函数应用于输入元素的结果，值是将值映射函数应用于所有等于键的输入元素的结果，并使用合并函数将它们组合起来
      参见:

    • toConcurrentMap

      public static <T, K, U> Collector<T,?,ConcurrentMap<K,U>> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
      返回一个并发Collector，将元素累积到一个ConcurrentMap中，其键和值是将提供的映射函数应用于输入元素的结果。

      如果映射的键包含重复项（根据Object.equals(Object)），在执行收集操作时将抛出IllegalStateException。如果映射的键可能有重复项，请改用toConcurrentMap(Function, Function, BinaryOperator)。

      对于返回的ConcurrentMap，不保证其类型、可变性或可序列化性。

      API注释:
      通常情况下，键或值中的一个是输入元素。在这种情况下，实用方法Function.identity()可能会有所帮助。例如，以下代码生成将学生映射到他们的平均绩点的ConcurrentMap： 
      
 ConcurrentMap<Student, Double> studentToGPA
   = students.stream().collect(
     toConcurrentMap(Function.identity(),
                     student -> computeGPA(student)));
      以下代码生成将唯一标识符映射到学生的ConcurrentMap： 
      
 ConcurrentMap<String, Student> studentIdToStudent
   = students.stream().collect(
     toConcurrentMap(Student::getId,
                     Function.identity()));

      这是一个concurrent和unordered收集器。

      类型参数:
      T - 输入元素的类型
      K - 键映射函数的输出类型
      U - 值映射函数的输出类型
      参数:
      keyMapper - 生成键的映射函数
      valueMapper - 生成值的映射函数
      返回值:
      一个并发的、无序的Collector，将元素收集到一个ConcurrentMap中，其中键是将键映射函数应用于输入元素的结果，值是将值映射函数应用于输入元素的结果
      参见:

    • toConcurrentMap

      public static <T, K, U> Collector<T,?,ConcurrentMap<K,U>> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)
      返回一个并发的Collector，将元素累积到一个ConcurrentMap中，其键和值是将提供的映射函数应用于输入元素的结果。

      如果映射的键包含重复项（根据Object.equals(Object)），则将值映射函数应用于每个相等的元素，并使用提供的合并函数合并结果。

      对于返回的ConcurrentMap，不保证其类型、可变性或可序列化性。

      API注释:
      处理多个元素映射到相同键之间的冲突有多种方法。其他形式的toConcurrentMap简单地使用一个无条件抛出异常的合并函数，但您可以轻松编写更灵活的合并策略。例如，如果您有一个Person流，想要生成一个将姓名映射到地址的“电话簿”，但可能有两个人有相同的姓名，您可以按照以下方式优雅地处理这些冲突，并生成将姓名映射到地址列表的ConcurrentMap： 
      
 ConcurrentMap<String, String> phoneBook
   = people.stream().collect(
     toConcurrentMap(Person::getName,
                     Person::getAddress,
                     (s, a) -> s + ", " + a));

      这是一个concurrent和unordered收集器。

      类型参数:
      T - 输入元素的类型
      K - 键映射函数的输出类型
      U - 值映射函数的输出类型
      参数:
      keyMapper - 生成键的映射函数
      valueMapper - 生成值的映射函数
      mergeFunction - 一个合并函数，用于解决与相同键关联的值之间的冲突，如提供给Map.merge(Object, Object, BiFunction)
      返回值:
      一个并发的、无序的Collector，将元素收集到一个ConcurrentMap中，其中键是将键映射函数应用于输入元素的结果，值是将值映射函数应用于所有等于键的输入元素的结果，并使用合并函数将它们组合起来
      参见:

    • toConcurrentMap

      public static <T, K, U, M extends ConcurrentMap<K, U>> Collector<T,?,M> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapFactory)
      返回一个并发的Collector，将元素累积到一个ConcurrentMap中，其键和值是将提供的映射函数应用于输入元素的结果。

      如果映射的键包含重复项（根据Object.equals(Object)），则将值映射函数应用于每个相等的元素，并使用提供的合并函数合并结果。由提供的供应商函数创建ConcurrentMap。

      这是一个concurrent和unordered收集器。

      类型参数:
      T - 输入元素的类型
      K - 键映射函数的输出类型
      U - 值映射函数的输出类型
      M - 结果ConcurrentMap的类型
      参数:
      keyMapper - 生成键的映射函数
      valueMapper - 生成值的映射函数
      mergeFunction - 一个合并函数，用于解决与相同键关联的值之间的冲突，如提供给Map.merge(Object, Object, BiFunction)
      mapFactory - 一个提供新的空ConcurrentMap的供应商函数，结果将插入其中
      返回值:
      一个并发的、无序的Collector，将元素收集到一个ConcurrentMap中，其中键是将键映射函数应用于输入元素的结果，值是将值映射函数应用于所有等于键的输入元素的结果，并使用合并函数将它们组合起来
      参见:

    • summarizingInt

      public static <T> Collector<T,?,IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)
      返回一个Collector，将一个int生成的映射函数应用于每个输入元素，并返回生成值的摘要统计信息。
      类型参数:
      T - 输入元素的类型
      参数:
      mapper - 应用于每个元素的映射函数
      返回值:
      实现摘要统计信息减少的Collector
      参见:

    • summarizingLong

      public static <T> Collector<T,?,LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)
      返回一个Collector，将一个long生成的映射函数应用于每个输入元素，并返回生成值的摘要统计信息。
      类型参数:
      T - 输入元素的类型
      参数:
      mapper - 应用于每个元素的映射函数
      返回值:
      实现摘要统计信息减少的Collector
      参见:

    • summarizingDouble

      public static <T> Collector<T,?,DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)
      返回一个Collector，将一个double生成的映射函数应用于每个输入元素，并返回生成值的摘要统计信息。
      类型参数:
      T - 输入元素的类型
      参数:
      mapper - 应用于每个元素的映射函数
      返回值:
      实现摘要统计信息减少的Collector
      参见:

    • teeing

      public static <T, R1, R2, R> Collector<T,?,R> teeing(Collector<? super T,?,R1> downstream1, Collector<? super T,?,R2> downstream2, BiFunction<? super R1,? super R2,R> merger)
      返回一个Collector，它是两个下游收集器的组合。传递给结果收集器的每个元素都会被两个下游收集器处理，然后使用指定的合并函数将它们的结果合并为最终结果。

      生成的收集器函数执行以下操作：

      • supplier: 创建一个包含通过调用每个收集器的supplier获得的结果容器的结果容器
      • accumulator: 使用其结果容器和输入元素调用每个收集器的accumulator
      • combiner: 使用两个结果容器调用每个收集器的combiner
      • finisher: 使用其结果容器调用每个收集器的finisher，然后调用提供的合并器并返回其结果。

      如果两个下游收集器都是无序的，则生成的收集器是Collector.Characteristics.UNORDERED，如果两个下游收集器都是并发的，则生成的收集器是Collector.Characteristics.CONCURRENT。

      类型参数:
      T - 输入元素的类型
      R1 - 第一个收集器的结果类型
      R2 - 第二个收集器的结果类型
      R - 最终结果的类型
      参数:
      downstream1 - 第一个下游收集器
      downstream2 - 第二个下游收集器
      merger - 将两个结果合并为单个结果的函数
      返回:
      一个Collector，它聚合了两个提供的收集器的结果。
      自版本:
      12