方法详细信息

• toCollection

  public static <T,​C extends Collection<T>> Collector<T,​?,​C> toCollection​(Supplier<C> collectionFactory)

  返回Collector ，其累积的输入元素融入到新的Collection ，在遭遇订单。 Collection由提供的工厂创建。

  参数类型

  T - 输入元素的类型

  C - 生成的 Collection的类型

  参数

  collectionFactory - 提供新空 Collection的供应商，其中将插入结果

  结果

  a 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 ， 它按顺序将输入元素累积到unmodifiable List中。 返回的收集器不允许空值，如果显示空值，则抛出NullPointerException 。

  参数类型

  T - 输入元素的类型

  结果

  一个 Collector ，其累积所述输入元件到 unmodifiable List在遭遇顺序

  从以下版本开始：

  10

• toSet

  public static <T> Collector<T,​?,​Set<T>> toSet()

  返回Collector ，将输入元素累积到新的Set 。 Set返回的类型，可变性，可串行性或线程安全性无法保证; 如果需要更多地控制返回的Set ，请使用toCollection(Supplier) 。

  这是一个收藏家unordered 。

  参数类型

  T - 输入元素的类型

  结果

  a Collector ，它将所有输入元素收集到 Set

• toUnmodifiableSet

  public static <T> Collector<T,​?,​Set<T>> toUnmodifiableSet()

  返回Collector ，将输入元素累积到unmodifiable Set中 。 返回的收集器不允许空值，如果显示空值，则抛出NullPointerException 。 如果输入包含重复元素，则保留重复项的任意元素。

  这是一个收藏家unordered 。

  参数类型

  T - 输入元素的类型

  结果

  Collector将输入元素累积到 unmodifiable Set中

  从以下版本开始：

  10

• joining

  public static Collector<CharSequence,​?,​String> joining()

  返回一个 Collector该串接的输入元素为 String ，在遭遇顺序。

  结果

  Collector按顺序将输入元素连接到 String

• joining

  public static Collector<CharSequence,​?,​String> joining​(CharSequence delimiter)

  返回 Collector ，它以连接 Collector连接由指定分隔符分隔的输入元素。

  参数

  delimiter - 每个元素之间使用的分隔符

  结果

  Collector ，它按顺序连接CharSequence元素，由指定的分隔符分隔

• joining

  public static Collector<CharSequence,​?,​String> joining​(CharSequence delimiter,
                                                                     CharSequence prefix,
                                                                     CharSequence suffix)

  返回 Collector ，它以指定的 Collector连接由指定的分隔符分隔的输入元素和指定的前缀和后缀。

  参数

  delimiter - 每个元素之间使用的分隔符

  prefix - 要在连接结果的开头使用的字符序列

  suffix - 要在连接结果的末尾使用的字符序列

  结果

  Collector以连接 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 Note:

  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 。 （如果映射的流是null ，则使用空流。）

  API Note:

  当用于多级还原时， 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 - 将收到mapper返回的流元素的收集器

  结果

  收集器，它将映射函数应用于输入元素，并将平面映射结果提供给下游收集器

  从以下版本开始：

  9

• filtering

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

  适应一个 Collector相同类型的一个接受元件 T通过将谓词给每个输入元素并且如果所述谓词仅返回累积 true 。

  API Note:

  当用于多级还原时， filtering()收集器最有用，例如groupingBy或partitioningBy下游。 例如，给定一个Employee的流，以累积每个部门中具有高于特定阈值的薪水的员工：

     Map<Department, Set<Employee>> wellPaidEmployeesByDepartment = employees.stream().collect( groupingBy(Employee::getDepartment, filtering(e -> e.getSalary() > 2000, toSet())));  

  过滤收集器与流的filter()操作不同。 在此示例中，假设在某些部门中没有员工的薪水高于阈值。 使用如上所示的过滤收集器将导致从该部门到空Set 。 如果filter()执行流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)

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

  Implementation Note:

  double格式可以表示-2 ⁵³到2 ⁵³范围内的所有连续整数。 如果管道具有超过2 ^53个值，则平均计算中的除数将饱和为2 ⁵³ ，从而导致额外的数值误差。

  参数类型

  T - 输入元素的类型

  参数

  mapper - 提取要平均的属性的函数

  结果

  Collector生成派生属性的算术平均值

• reducing

  public static <T> Collector<T,​?,​T> reducing​(T identity,
                                                          BinaryOperator<T> op)

  返回 Collector ，使用提供的标识在指定的 BinaryOperator下执行其输入元素的减少。

  API Note:

  当用于groupingBy或partitioningBy下游的多级还原时， reducing()收集器最有用。 要对流执行简单缩减，请改用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 Note:

  当用于多级还原时， 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<U> op)

  返回Collector ，它在指定的映射函数和BinaryOperator下执行其输入元素的减少。 这是reducing(Object, BinaryOperator)的概括，其允许在还原之前转换元素。

  API Note:

  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<U>

  结果

  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>>其键是将分类函数应用于输入元素所得的值，其对应值为List其中包含映射到分类函数下的关联键的输入元素。

  无法保证返回的Map或List对象的类型，可变性，可序列化或线程安全性。

  实现要求：

  这会产生类似于的结果：

     groupingBy(classifier, toList());  

  Implementation Note:

  返回的Collector不是并发的。 对于并行流管道， combiner功能通过将键从一个映射合并到另一个映射来运行，这可能是一项昂贵的操作。 如果不需要保留元素出现在生成的Map收集器中的顺序，则使用groupingByConcurrent(Function)可以提供更好的并行性能。

  参数类型

  T - 输入元素的类型

  K - 键的类型

  参数

  classifier - 将输入元素映射到键的分类器函数

  结果

  a 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 ，不保证其类型，可变性，可串行性或线程安全性。

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

     Map<City, Set<String>> namesByCity = people.stream().collect( groupingBy(Person::getCity, mapping(Person::getLastName, toSet())));  

  Implementation Note:

  返回的Collector不是并发的。 对于并行流管道， combiner功能通过将键从一个映射合并到另一个映射来进行操作，这可能是一项昂贵的操作。 如果不需要保留向下游收集器提供元素的顺序，则使用groupingByConcurrent(Function, Collector)可以提供更好的并行性能。

  参数类型

  T - 输入元素的类型

  K - 键的类型

  A - 下游收集器的中间累积类型

  D - 下游缩减的结果类型

  参数

  classifier - 将输入元素映射到键的分类器函数

  downstream - 实现下游减少的 Collector

  结果

  a 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 。 收集器生成的Map使用提供的工厂功能创建。

  分类函数将元素映射到某些键类型K 。 下游收集器上类型的元素进行操作T并产生类型的结果D 。 得到的收集器产生Map<K, D> 。

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

     Map<City, Set<String>> namesByCity = people.stream().collect( groupingBy(Person::getCity, TreeMap::new, mapping(Person::getLastName, toSet())));  

  Implementation Note:

  返回的Collector不是并发的。 对于并行流管道， combiner功能通过将键从一个映射合并到另一个映射来运行，这可能是一项昂贵的操作。 如果不需要保留向下游收集器提供元素的顺序，则使用groupingByConcurrent(Function, Supplier, Collector)可以提供更好的并行性能。

  参数类型

  T - 输入元素的类型

  K - 键的类型

  A - 下游收集器的中间累积类型

  D - 下游缩减的结果类型

  M - 生成的 Map的类型

  参数

  classifier - 将输入元素映射到键的分类器函数

  downstream - 实现下游减少的 Collector

  mapFactory - 提供新空 Map的供应商，其中将插入结果

  结果

  a 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>>其键是将分类函数应用于输入元素所得的值，其对应值为List s，其中包含映射到分类函数下的关联键的输入元素。

  还有的类型，可变性，或串行化的任何保证ConcurrentMap或List对象返回，或的线程安全的List对象返回。

  实现要求：

  这会产生类似于的结果：

     groupingByConcurrent(classifier, toList());  

  参数类型

  T - 输入元素的类型

  K - 键的类型

  参数

  classifier - 将输入元素映射到键的分类器函数

  结果

  实现group-by操作的并发无序 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 ，不保证其类型，可变性或可串行性。

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

     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 - 将输入元素映射到键的分类器函数

  downstream - 执行下游减少的 Collector

  mapFactory - 提供新空 ConcurrentMap的供应商，其中将插入结果

  结果

  并发，无序 Collector实现级联group-by操作

  另请参见：

  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键的映射。 List返回的Map或List ，不保证其类型，可变性，可串行性或线程安全性。

  API Note:

  如果分区没有元素，则结果Map中的值将为空List。

  参数类型

  T - 输入元素的类型

  参数

  predicate - 用于对输入元素进行分类的谓词

  结果

  a 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返回的Map ，不保证其类型，可变性，可串行性或线程安全性。

  API Note:

  如果分区没有元素，则通过调用下游收集器的供应商功能然后应用修整器功能来获取结果Map中的值。

  参数类型

  T - 输入元素的类型

  A - 下游收集器的中间累积类型

  D - 下游缩减的结果类型

  参数

  predicate - 用于对输入元素进行分类的谓词

  downstream - 实现下游减少的 Collector

  结果

  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其键和值是将提供的映射函数应用于输入元素的结果。

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

  Map返回的Map ，不保证其类型，可变性，可串行性或线程安全性。

  API Note:

  键或值通常是输入元素。 在这种情况下，实用方法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()));  

  Implementation Note:

  返回的Collector不是并发的。 对于并行流管道， combiner功能通过将键从一个映射合并到另一个映射来操作，这可能是昂贵的操作。 如果不需要将结果按顺序插入Map ，则使用toConcurrentMap(Function, Function)可以提供更好的并行性能。

  参数类型

  T - 输入元素的类型

  K - 键映射函数的输出类型

  U - 值映射函数的输出类型

  参数

  keyMapper - 用于生成密钥的映射函数

  valueMapper - 用于生成值的映射函数

  结果

  a 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 ，它将输入元素累积到unmodifiable Map中 ，其键和值是将提供的映射函数应用于输入元素的结果。

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

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

  参数类型

  T - 输入元素的类型

  K - 键映射函数的输出类型

  U - 值映射函数的输出类型

  参数

  keyMapper - 用于生成密钥的映射函数，必须为非null

  valueMapper - 用于生成值的映射函数，必须为非null

  结果

  Collector将输入元素累积到 unmodifiable Map中 ，其键和值是将提供的映射函数应用于输入元素的结果

  异常

  NullPointerException - 如果keyMapper或valueMapper为null

  从以下版本开始：

  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<U> mergeFunction)

  返回Collector ，它将元素累积到Map其键和值是将提供的映射函数应用于输入元素的结果。

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

  Map返回的Map ，不保证其类型，可变性，可串行性或线程安全性。

  API Note:

  有多种方法可以处理映射到同一个键的多个元素之间的冲突。 toMap的其他形式只使用无条件抛出的合并函数，但您可以轻松编写更灵活的合并策略。 例如，如果您有一个Person的流，并且您想要生成一个“电话簿”映射名称来解决，但是有两个人可能具有相同的名称，您可以按照以下方式优雅地处理这些冲突，并生成Map映射名称到连接的地址列表：

     Map<String, String> phoneBook = people.stream().collect( toMap(Person::getName, Person::getAddress, (s, a) -> s + ", " + a));  

  Implementation Note:

  返回的Collector不是并发的。 对于并行流管道， combiner功能通过将键从一个映射合并到另一个映射来进行操作，这可能是一项昂贵的操作。 如果不要求结果以遭遇顺序合并到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<U> mergeFunction)

  返回Collector ，它将输入元素累积到unmodifiable Map中 ，其键和值是将提供的映射函数应用于输入元素的结果。

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

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

  参数类型

  T - 输入元素的类型

  K - 键映射函数的输出类型

  U - 值映射函数的输出类型

  参数

  keyMapper - 用于生成密钥的映射函数，必须为非null

  valueMapper - 用于生成值的映射函数必须为非null

  mergeFunction - 用于解决与同一密钥关联的值之间的冲突的合并函数（如提供给 Map.merge(Object, Object, BiFunction) ）必须为非null

  结果

  Collector将输入元素累积到 unmodifiable 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<U> mergeFunction,
                                                                                                      Supplier<M> mapFactory)

  返回Collector ，它将元素累积到Map其键和值是将提供的映射函数应用于输入元素的结果。

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

  Implementation Note:

  返回的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其键是将键映射函数应用于输入元素的结果，其值是将值映射函数应用于与键相等的所有输入元素并使用合并将它们组合的结果功能

  另请参见：

  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其键和值是将提供的映射函数应用于输入元素的结果。

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

  ConcurrentMap返回的ConcurrentMap ，不保证其类型，可变性或可串行性。

  API Note:

  键或值通常是输入元素。 在这种情况下，实用方法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<U> mergeFunction)

  返回并发Collector ，它将元素累积到ConcurrentMap其键和值是将提供的映射函数应用于输入元素的结果。

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

  ConcurrentMap返回的ConcurrentMap ，不保证其类型，可变性或可串行性。

  API Note:

  有多种方法可以处理映射到同一个键的多个元素之间的冲突。 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<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其键是将键映射函数应用于输入元素的结果，其值是将值映射函数应用于等于键的所有输入元素并将它们组合的结果使用合并功能

  另请参见：

  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 - 应用于每个元素的映射函数

  结果

  a Collector实现汇总统计数据减少

  另请参见：

  summarizingDouble(ToDoubleFunction) ， summarizingLong(ToLongFunction)

• summarizingLong

  public static <T> Collector<T,​?,​LongSummaryStatistics> summarizingLong​(ToLongFunction<? super T> mapper)

  返回 Collector ， long映射函数应用于每个输入元素，并返回结果值的摘要统计信息。

  参数类型

  T - 输入元素的类型

  参数

  mapper - 要应用于每个元素的映射函数

  结果

  a Collector实现摘要统计减少

  另请参见：

  summarizingDouble(ToDoubleFunction) ， summarizingInt(ToIntFunction)

• summarizingDouble

  public static <T> Collector<T,​?,​DoubleSummaryStatistics> summarizingDouble​(ToDoubleFunction<? super T> mapper)

  返回 Collector ， double映射函数应用于每个输入元素，并返回结果值的摘要统计信息。

  参数类型

  T - 输入元素的类型

  参数

  mapper - 应用于每个元素的映射函数

  结果

  a Collector实现摘要统计减少

  另请参见：

  summarizingLong(ToLongFunction) ， summarizingInt(ToIntFunction)