java.lang.Object

java.util.stream.Collectors

public final class Collectors extends Object

Collector 的实现实现了各种有用的归约操作，例如将元素累积到集合中、根据各种条件汇总元素等。

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


 // Accumulate names into a List
 List<String> list = people.stream()
  .map(Person::getName)
  .collect(Collectors.toList());

 // Accumulate names into a TreeSet
 Set<String> set = people.stream()
  .map(Person::getName)
  .collect(Collectors.toCollection(TreeSet::new));

 // Convert elements to strings and concatenate them, separated by commas
 String joined = things.stream()
  .map(Object::toString)
  .collect(Collectors.joining(", "));

 // Compute sum of salaries of employee
 int total = employees.stream()
  .collect(Collectors.summingInt(Employee::getSalary));

 // Group employees by department
 Map<Department, List<Employee>> byDept = employees.stream()
  .collect(Collectors.groupingBy(Employee::getDepartment));

 // Compute sum of salaries by department
 Map<Department, Integer> totalByDept = employees.stream()
  .collect(Collectors.groupingBy(Employee::getDepartment,
                 Collectors.summingInt(Employee::getSalary)));

 // Partition students into passing and failing
 Map<Boolean, List<Student>> passingFailing = students.stream()
  .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));

自从：: 1.8

方法总结

修饰符和类型

方法

描述

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()

返回一个 Collector 接受类型为 T 的元素，它计算输入元素的数量。

static <T, A, R> Collector<T,?,R>

filtering(Predicate<? super T> predicate, Collector<? super T,A,R> downstream)

通过将谓词应用于每个输入元素并仅在谓词返回 true 时才累积，使 Collector 适应一个接受相同类型 T 的元素。

static <T, U, A, R> Collector<T,?,R>

flatMapping(Function<? super T,? extends Stream<? extends U>> mapper, Collector<? super U,A,R> downstream)

通过在累加之前对每个输入元素应用平面映射函数，使 Collector 接受类型为 U 的元素适应一个接受类型为 T 的元素。

static <T, K> Collector<T,?,Map<K,List<T>>>

groupingBy(Function<? super T,? extends K> classifier)

返回一个 Collector 对类型为 T 的输入元素执行“分组依据”操作，根据分类函数对元素进行分组，并在 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)

返回一个 Collector 对类型为 T 的输入元素实施级联“分组依据”操作，根据分类函数对元素进行分组，然后使用指定的下游 Collector 对与给定键关联的值执行缩减操作。

static <T, K, A, D> Collector<T,?,Map<K,D>>

groupingBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)

返回一个 Collector 对类型为 T 的输入元素实施级联“分组依据”操作，根据分类函数对元素进行分组，然后使用指定的下游 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)

通过在累加之前对每个输入元素应用映射函数，使 Collector 接受类型为 U 的元素适应一个接受类型为 T 的元素。

static <T> Collector<T,?,Optional<T>>

maxBy(Comparator<? super T> comparator)

返回根据给定的 Comparator 生成最大元素的 Collector，描述为 Optional<T>。

static <T> Collector<T,?,Optional<T>>

minBy(Comparator<? super T> comparator)

返回根据给定的 Comparator 生成最小元素的 Collector，描述为 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 op)

返回一个 Collector，它在指定的map函数和 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 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 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 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 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 mergeFunction)

返回一个 Collector ，它将输入元素累积到一个不可修改的map 中，其键和值是将提供的映射函数应用于输入元素的结果。

static <T> Collector<T,?,Set<T>>

toUnmodifiableSet()

返回将输入元素累积到不可修改的集合中的 Collector。

在类 java.lang.Object 中声明的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

方法详情
- 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 - 输入元素的类型
 
 返回：
 
 a Collector 将所有输入元素收集到 List 中，按遇到顺序
- toUnmodifiableList
 
 public static <T> Collector <T,?,List <T>> toUnmodifiableList()
 
 返回一个 Collector，它将输入元素按遇到顺序累积到不可修改的列表中。返回的 Collector 不允许使用 null 值，如果它出现 null 值，将抛出 NullPointerException。
 
 类型参数：
 
 T - 输入元素的类型
 
 返回：
 
 一个 Collector 将输入元素按遇到顺序累积到不可修改的列表中
 
 自从：
 
 10
- toSet
 
 public static <T> Collector <T,?,Set <T>> toSet()
 
 返回一个 Collector ，它将输入元素累积到一个新的 Set 中。返回的 Set 的类型、可变性、可序列化性或线程安全性无法保证；如果需要对返回的 Set 进行更多控制，请使用 toCollection(Supplier) 。
 这是一个 unordered 收集器。
 
 类型参数：
 
 T - 输入元素的类型
 
 返回：
 
 Collector 将所有输入元素收集到 Set
- toUnmodifiableSet
 
 public static <T> Collector <T,?,Set <T>> toUnmodifiableSet()
 
 返回将输入元素累积到不可修改的集合中的 Collector。返回的 Collector 不允许使用 null 值，如果它出现 null 值，将抛出 NullPointerException。如果输入包含重复元素，则保留重复项的任意元素。
 这是一个 unordered 收集器。
 
 类型参数：
 
 T - 输入元素的类型
 
 返回：
 
 将输入元素累积到不可修改的集合中的 Collector
 
 自从：
 
 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)
 
 通过在累加之前对每个输入元素应用映射函数，使 Collector 接受类型为 U 的元素适应一个接受类型为 T 的元素。
 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)
 
 通过在累加之前对每个输入元素应用平面映射函数，使 Collector 接受类型为 U 的元素适应一个接受类型为 T 的元素。平面映射函数将输入元素映射到 stream 覆盖零个或多个输出元素，然后在下游累积。每个映射流在其内容被放置到下游之后是closed 。（如果map流是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 - 一个收集器，它将接收映射器返回的流元素
 
 返回：
 
 将映射函数应用于输入元素并将平面映射结果提供给下游收集器的收集器
 
 自从：
 
 9
- filtering
 
 public static <T, A, R> Collector <T,?,R> filtering(Predicate <? super T> predicate, Collector <? super T,A,R> downstream)
 
 通过将谓词应用于每个输入元素并仅在谓词返回 true 时才累积，使 Collector 适应一个接受相同类型 T 的元素。
 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 - 一个收集器，它将接受与谓词匹配的值
 
 返回：
 
 将谓词应用于输入元素并向下游收集器提供匹配元素的收集器
 
 自从：
 
 9
- collectingAndThen
 
 public static <T, A, R, RR> Collector <T,A,RR> collectingAndThen(Collector <T,A,R> downstream, Function <R,RR> finisher)
 调整 Collector 以执行额外的整理转换。例如，可以调整 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()
 
 返回一个 Collector 接受类型为 T 的元素，它计算输入元素的数量。如果不存在任何元素，则结果为 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)
 
 返回根据给定的 Comparator 生成最大元素的 Collector，描述为 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格式可以表示-2范围内的所有连续整数⁵³至 2⁵³.如果管道有超过 2⁵³值，平均计算中的除数将在 2 处饱和⁵³，导致额外的数值错误。
 
 类型参数：
 
 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(BinaryOperator)
 
 reducing(Object, Function, BinaryOperator)
- 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(Object, BinaryOperator)
 
 reducing(Object, Function, BinaryOperator)
- reducing
 
 public static <T, U> Collector <T,?,U> reducing(U identity, Function <? super T,? extends U> mapper, BinaryOperator op)
 
 返回一个 Collector，它在指定的map函数和 BinaryOperator 下执行其输入元素的缩减。这是 reducing(Object, BinaryOperator) 的推广，它允许在缩减之前对元素进行转换。
 API 注意：
 
 reducing() 收集器在 groupingBy 或 partitioningBy 下游的多级缩减中使用时最有用。要对流执行简单的 map-reduce，请改用 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
 
 返回：
 
 a Collector 实现 map-reduce 操作
 
 参见：
 
 reducing(Object, BinaryOperator)
 
 reducing(BinaryOperator)
- 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>>，其键是将分类函数应用于输入元素所产生的值，其对应的值为Lists，其中包含映射到分类函数下关联键的输入元素。
 
 不保证返回的 Map 或 List 对象的类型、可变性、可序列化性或线程安全性。
 实现要求：
 
 这会产生类似于以下内容的结果：
 groupingBy(classifier, toList());
 
 实现注意事项：
 
 返回的Collector不是并发的。对于并行流管道，combiner 函数通过将键从一个映射合并到另一个map来运行，这可能是一项昂贵的操作。如果不需要保留元素在生成的 Map 收集器中出现的顺序，则使用 groupingByConcurrent(Function) 可能会提供更好的并行性能。
 
 类型参数：
 
 T - 输入元素的类型
 
 K - 键的类型
 
 参数：
 
 classifier - 将输入元素映射到键的分类器函数
 
 返回：
 
 Collector 实现分组操作
 
 参见：
 
 groupingBy(Function, Collector)
 
 groupingBy(Function, Supplier, Collector)
 
 groupingByConcurrent(Function)
- 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 对类型为 T 的输入元素实施级联“分组依据”操作，根据分类函数对元素进行分组，然后使用指定的下游 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 函数通过将键从一个映射合并到另一个map来运行，这可能是一项昂贵的操作。如果不需要保留元素呈现给下游收集器的顺序，则使用 groupingByConcurrent(Function, Collector) 可能会提供更好的并行性能。
 
 类型参数：
 
 T - 输入元素的类型
 
 K - 键的类型
 
 A - 下游收集器的中间累积类型
 
 D - 下游归约的结果类型
 
 参数：
 
 classifier - 将输入元素映射到键的分类器函数
 
 downstream - 一个 Collector 实施下游减少
 
 返回：
 
 Collector 实现级联分组操作
 
 参见：
 
 groupingBy(Function)
 
 groupingBy(Function, Supplier, Collector)
 
 groupingByConcurrent(Function, 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 对类型为 T 的输入元素实施级联“分组依据”操作，根据分类函数对元素进行分组，然后使用指定的下游 Collector 对与给定键关联的值执行缩减操作。 Collector 生成的 Map 是使用提供的工厂函数创建的。
 分类函数将元素映射到某个键类型 K 。下游收集器对 T 类型的元素进行操作并产生 D 类型的结果。生成的收集器生成一个 Map<K, D> 。
 
 例如，要计算每个城市中人们的姓氏集合，其中城市名称是排序的：
 
 Map<City, Set<String>> namesByCity = people.stream().collect( groupingBy(Person::getCity, TreeMap::new, mapping(Person::getLastName, toSet())));
 实现注意事项：
 
 返回的Collector不是并发的。对于并行流管道，combiner 函数通过将键从一个映射合并到另一个map来运行，这可能是一项昂贵的操作。如果不需要保留元素呈现给下游收集器的顺序，则使用 groupingByConcurrent(Function, Supplier, Collector) 可能会提供更好的并行性能。
 
 类型参数：
 
 T - 输入元素的类型
 
 K - 键的类型
 
 D - 下游归约的结果类型
 
 A - 下游收集器的中间累积类型
 
 M - 结果的类型 Map
 
 参数：
 
 classifier - 将输入元素映射到键的分类器函数
 
 mapFactory - 供应商提供一个新的空 Map，结果将插入其中
 
 downstream - 一个 Collector 实施下游减少
 
 返回：
 
 Collector 实现级联分组操作
 
 参见：
 
 groupingBy(Function, Collector)
 
 groupingBy(Function)
 
 groupingByConcurrent(Function, Supplier, Collector)
- groupingByConcurrent
 
 public static <T, K> Collector <T,?,ConcurrentMap <K,List <T>>> groupingByConcurrent(Function <? super T,? extends K> classifier)
 
 返回并发 Collector 对类型为 T 的输入元素执行“分组依据”操作，根据分类函数对元素进行分组。
 这是 concurrent 和 unordered 收集器。
 
 分类函数将元素映射到某个键类型 K 。收集器生成一个ConcurrentMap<K, List<T>>，其键是将分类函数应用于输入元素所产生的值，其对应的值为Lists，其中包含映射到分类函数下关联键的输入元素。
 
 不保证返回的 ConcurrentMap 或 List 对象的类型、可变性或可序列化性，也不保证返回的 List 对象的线程安全性。
 实现要求：
 
 这会产生类似于以下内容的结果：
 groupingByConcurrent(classifier, toList());
 
 类型参数：
 
 T - 输入元素的类型
 
 K - 键的类型
 
 参数：
 
 classifier - 将输入元素映射到键的分类器函数
 
 返回：
 
 一个并发的、无序的Collector实现分组操作
 
 参见：
 
 groupingBy(Function)
 
 groupingByConcurrent(Function, Collector)
 
 groupingByConcurrent(Function, Supplier, 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 对类型为 T 的输入元素实施级联“分组依据”操作，根据分类函数对元素进行分组，然后使用指定的下游 Collector 对与给定键关联的值执行缩减操作。
 这是 concurrent 和 unordered 收集器。
 
 分类函数将元素映射到某个键类型 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实现级联分组操作
 
 参见：
 
 groupingBy(Function, Collector)
 
 groupingByConcurrent(Function)
 
 groupingByConcurrent(Function, Supplier, 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 是使用提供的工厂函数创建的。
 这是 concurrent 和 unordered 收集器。
 
 分类函数将元素映射到某个键类型 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实现级联分组操作
 
 参见：
 
 groupingByConcurrent(Function)
 
 groupingByConcurrent(Function, Collector)
 
 groupingBy(Function, Supplier, 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 或 List 的类型、可变性、可序列化性或线程安全性。
 API 注意：
 
 如果一个分区没有元素，它在结果 Map 中的值将是一个空列表。
 
 类型参数：
 
 T - 输入元素的类型
 
 参数：
 
 predicate - 用于对输入元素进行分类的谓词
 
 返回：
 
 Collector 实现分区操作
 
 参见：
 
 partitioningBy(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 注意：
 
 如果一个partition没有元素，它在结果Map中的值将通过调用下游收集器的supplier函数，然后应用finisher函数来获取。
 
 类型参数：
 
 T - 输入元素的类型
 
 D - 下游归约的结果类型
 
 A - 下游收集器的中间累积类型
 
 参数：
 
 predicate - 用于对输入元素进行分类的谓词
 
 downstream - 一个 Collector 实施下游减少
 
 返回：
 
 a Collector 实现级联分区操作
 
 参见：
 
 partitioningBy(Predicate)
- 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 中，其键和值是将提供的映射函数应用于输入元素的结果。
 如果map的键包含重复项（根据 Object.equals(Object) ），则在执行收集操作时抛出 IllegalStateException。如果map的键可能有重复项，请改用 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，则使用 toConcurrentMap(Function, Function) 可能会提供更好的并行性能。
 
 类型参数：
 
 T - 输入元素的类型
 
 K - 按键映射函数的输出类型
 
 U - 值映射函数的输出类型
 
 参数：
 
 keyMapper - 生成键的映射函数
 
 valueMapper - 生成值的映射函数
 
 返回：
 
 Collector 将元素收集到 Map 中，其键和值是将映射函数应用于输入元素的结果
 
 参见：
 
 toMap(Function, Function, BinaryOperator)
 
 toMap(Function, Function, BinaryOperator, Supplier)
 
 toConcurrentMap(Function, Function)
- 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 中，其键和值是将提供的映射函数应用于输入元素的结果。
 如果map的键包含重复项（根据 Object.equals(Object) ），则在执行收集操作时抛出 IllegalStateException。如果map的键可能有重复项，请使用 toUnmodifiableMap(Function, Function, BinaryOperator) 来处理值的合并。
 
 返回的 Collector 不允许空键和空值。如果任一映射函数返回 null，将抛出 NullPointerException。
 类型参数：
 
 T - 输入元素的类型
 
 K - 按键映射函数的输出类型
 
 U - 值映射函数的输出类型
 
 参数：
 
 keyMapper - 生成键的映射函数，必须为非空
 
 valueMapper - 生成值的映射函数，必须为非空
 
 返回：
 
 一个 Collector 将输入元素累积到一个不可修改的map 中，其键和值是将提供的映射函数应用于输入元素的结果
 
 抛出：
 
 NullPointerException - 如果 keyMapper 或 valueMapper 为空
 
 自从：
 
 10
 
 参见：
 
 toUnmodifiableMap(Function, Function, BinaryOperator)
- 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 mergeFunction)
 
 返回一个 Collector，它将元素累积到一个 Map 中，其键和值是将提供的映射函数应用于输入元素的结果。
 如果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来运行，这可能是一项昂贵的操作。如果不需要将结果按遇到顺序合并到 Map 中，则使用 toConcurrentMap(Function, Function, BinaryOperator) 可能会提供更好的并行性能。
 
 类型参数：
 
 T - 输入元素的类型
 
 K - 按键映射函数的输出类型
 
 U - 值映射函数的输出类型
 
 参数：
 
 keyMapper - 生成键的映射函数
 
 valueMapper - 生成值的映射函数
 
 mergeFunction - 合并函数，用于解决与相同键关联的值之间的冲突，如提供给 Map.merge(Object, Object, BiFunction)
 
 返回：
 
 Collector 将元素收集到 Map 中，其键是将键映射函数应用于输入元素的结果，其值是将值映射函数应用于等于键的所有输入元素并使用合并将它们组合的结果功能
 
 参见：
 
 toMap(Function, Function)
 
 toMap(Function, Function, BinaryOperator, Supplier)
 
 toConcurrentMap(Function, Function, BinaryOperator)
- 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 mergeFunction)
 
 返回一个 Collector ，它将输入元素累积到一个不可修改的map 中，其键和值是将提供的映射函数应用于输入元素的结果。
 如果map键包含重复项（根据 Object.equals(Object) ），值映射函数将应用于每个相等的元素，并使用提供的合并函数合并结果。
 
 返回的 Collector 不允许空键和空值。如果任一映射函数返回 null，将抛出 NullPointerException。
 类型参数：
 
 T - 输入元素的类型
 
 K - 按键映射函数的输出类型
 
 U - 值映射函数的输出类型
 
 参数：
 
 keyMapper - 生成键的映射函数，必须为非空
 
 valueMapper - 生成值的映射函数，必须为非空
 
 mergeFunction - 合并函数，用于解决与相同键关联的值之间的冲突，如提供给 Map.merge(Object, Object, BiFunction) ，必须是非空的
 
 返回：
 
 一个 Collector 将输入元素累积到一个不可修改的map 中，其键和值是将提供的映射函数应用于输入元素的结果
 
 抛出：
 
 NullPointerException - 如果 keyMapper、valueMapper 或 mergeFunction 为 null
 
 自从：
 
 10
 
 参见：
 
 toUnmodifiableMap(Function, Function)
- 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 mergeFunction, Supplier <M> mapFactory)
 
 返回一个 Collector，它将元素累积到一个 Map 中，其键和值是将提供的映射函数应用于输入元素的结果。
 如果map键包含重复项（根据 Object.equals(Object) ），值映射函数将应用于每个相等的元素，并使用提供的合并函数合并结果。 Map 由提供的供应商函数创建。
 实现注意事项：
 
 返回的Collector不是并发的。对于并行流管道，combiner 函数通过将键从一个映射合并到另一个map来运行，这可能是一项昂贵的操作。如果不需要将结果按遇到顺序合并到 Map 中，则使用 toConcurrentMap(Function, Function, BinaryOperator, Supplier) 可能会提供更好的并行性能。
 
 类型参数：
 
 T - 输入元素的类型
 
 K - 按键映射函数的输出类型
 
 U - 值映射函数的输出类型
 
 M - 结果的类型 Map
 
 参数：
 
 keyMapper - 生成键的映射函数
 
 valueMapper - 生成值的映射函数
 
 mergeFunction - 合并函数，用于解决与相同键关联的值之间的冲突，如提供给 Map.merge(Object, Object, BiFunction)
 
 mapFactory - 供应商提供一个新的空 Map，结果将插入其中
 
 返回：
 
 Collector 将元素收集到 Map 中，其键是将键映射函数应用于输入元素的结果，其值是将值映射函数应用于等于键的所有输入元素并使用合并将它们组合的结果功能
 
 参见：
 
 toMap(Function, Function)
 
 toMap(Function, Function, BinaryOperator)
 
 toConcurrentMap(Function, Function, BinaryOperator, Supplier)
- 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 中，其键和值是将提供的映射函数应用于输入元素的结果。
 如果map键包含重复项（根据 Object.equals(Object) ），则在执行收集操作时抛出 IllegalStateException。如果map的键可能有重复项，请改用 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 中，其键是将键映射函数应用于输入元素的结果，其值是将值映射函数应用于输入元素的结果
 
 参见：
 
 toMap(Function, Function)
 
 toConcurrentMap(Function, Function, BinaryOperator)
 
 toConcurrentMap(Function, Function, BinaryOperator, Supplier)
- 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 mergeFunction)
 
 返回并发的 Collector 将元素累积到 ConcurrentMap 中，其键和值是将提供的映射函数应用于输入元素的结果。
 如果map键包含重复项（根据 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(Function, Function)
 
 toConcurrentMap(Function, Function, BinaryOperator, Supplier)
 
 toMap(Function, Function, BinaryOperator)
- 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 mergeFunction, Supplier <M> mapFactory)
 
 返回并发的 Collector 将元素累积到 ConcurrentMap 中，其键和值是将提供的映射函数应用于输入元素的结果。
 如果map键包含重复项（根据 Object.equals(Object) ），值映射函数将应用于每个相等的元素，并使用提供的合并函数合并结果。 ConcurrentMap 由提供的供应商函数创建。
 
 这是 concurrent 和 unordered 收集器。
 类型参数：
 
 T - 输入元素的类型
 
 K - 按键映射函数的输出类型
 
 U - 值映射函数的输出类型
 
 M - 结果 ConcurrentMap 的类型
 
 参数：
 
 keyMapper - 生成键的映射函数
 
 valueMapper - 生成值的映射函数
 
 mergeFunction - 合并函数，用于解决与相同键关联的值之间的冲突，如提供给 Map.merge(Object, Object, BiFunction)
 
 mapFactory - 供应商提供一个新的空 ConcurrentMap，结果将插入其中
 
 返回：
 
 并发的、无序的 Collector 将元素收集到 ConcurrentMap 中，其键是对输入元素应用键映射函数的结果，其值是对等于键的所有输入元素应用值映射函数并将它们组合的结果使用合并功能
 
 参见：
 
 toConcurrentMap(Function, Function)
 
 toConcurrentMap(Function, Function, BinaryOperator)
 
 toMap(Function, Function, BinaryOperator, Supplier)
- summarizingInt
 
 public static <T> Collector <T,?,IntSummaryStatistics > summarizingInt(ToIntFunction <? super T> mapper)
 
 返回一个 Collector，它将 int 生成映射函数应用于每个输入元素，并返回结果值的汇总统计信息。
 类型参数：
 
 T - 输入元素的类型
 
 参数：
 
 mapper - 应用于每个元素的映射函数
 
 返回：
 
 Collector 实施摘要统计减少
 
 参见：
 
 summarizingDouble(ToDoubleFunction)
 
 summarizingLong(ToLongFunction)
- summarizingLong
 
 public static <T> Collector <T,?,LongSummaryStatistics > summarizingLong(ToLongFunction <? super T> mapper)
 
 返回一个 Collector，它将 long 生成的映射函数应用于每个输入元素，并返回结果值的汇总统计信息。
 类型参数：
 
 T - 输入元素的类型
 
 参数：
 
 mapper - 应用于每个元素的映射函数
 
 返回：
 
 Collector 实施摘要统计减少
 
 参见：
 
 summarizingDouble(ToDoubleFunction)
 
 summarizingInt(ToIntFunction)
- summarizingDouble
 
 public static <T> Collector <T,?,DoubleSummaryStatistics > summarizingDouble(ToDoubleFunction <? super T> mapper)
 
 返回一个 Collector，它将 double 生成的映射函数应用于每个输入元素，并返回结果值的汇总统计信息。
 类型参数：
 
 T - 输入元素的类型
 
 参数：
 
 mapper - 应用于每个元素的映射函数
 
 返回：
 
 Collector 实施摘要统计减少
 
 参见：
 
 summarizingLong(ToLongFunction)
 
 summarizingInt(ToIntFunction)
- 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：创建一个结果容器，其中包含通过调用每个收集器的供应商获得的结果容器
 
 累加器：调用每个收集器的累加器及其结果容器和输入元素
 
 组合器：用两个结果容器调用每个收集器的组合器
 
 finisher：调用每个收集器的 finisher 及其结果容器，然后调用提供的合并并返回其结果。
 
 如果两个下游收集器都是无序的，则生成的收集器是Collector.Characteristics.UNORDERED ；如果两个下游收集器是并发的，则生成的收集器是Collector.Characteristics.CONCURRENT 。
 类型参数：
 
 T - 输入元素的类型
 
 R1 - 第一个收集器的结果类型
 
 R2 - 第二个收集器的结果类型
 
 R - 最终结果类型
 
 参数：
 
 downstream1 - 第一个下游收集器
 
 downstream2 - 第二个下游收集器
 
 merger - 将两个结果合并为一个结果的函数
 
 返回：
 
 Collector 聚合了两个提供的收集器的结果。
 
 自从：
 
 12

类 Collectors

方法总结

在类 java.lang.Object 中声明的方法

方法详情

toCollection

toList

toUnmodifiableList

toSet

toUnmodifiableSet

joining

joining

joining

mapping

flatMapping

filtering

collectingAndThen

counting

minBy

maxBy

summingInt

summingLong

summingDouble

averagingInt

averagingLong

averagingDouble

reducing

reducing

reducing

groupingBy

groupingBy

groupingBy

groupingByConcurrent

groupingByConcurrent

groupingByConcurrent

partitioningBy

partitioningBy

toMap

toUnmodifiableMap

toMap

toUnmodifiableMap

toMap

toConcurrentMap

toConcurrentMap

toConcurrentMap

summarizingInt

summarizingLong

summarizingDouble

teeing