Module java.base

软件包 java.util.stream

Class Collectors

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

方法摘要

Modifier and Type	方法	描述
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)	适应一个 Collector相同类型的一个接受元件 T通过将谓词给每个输入元素并且如果所述谓词仅返回累积 true 。
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)	返回一个 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,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 。

Methods inherited from class 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 - 输入元素的类型

结果

一个 Collector将所有输入元素收集到一个 List ，按照顺序

toSet

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

返回一个Collector ，将输入元素累加到一个新的Set 。 Set返回的类型，可变性，可序列化或线程安全性没有保证; 如果需要更多的控制返回Set ，请使用toCollection(Supplier) 。

这是一个unordered收藏家。

参数类型

T - 输入元素的类型

结果

一个 Collector将所有输入元素收集到一个 Set

joining

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

返回一个 Collector ，按照遇到的顺序将输入元素连接到一个 String 。

结果

一个 Collector将输入元素连接到一个 String ，按照顺序

joining

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

返回一个 Collector ，按照遇到的顺序连接由指定的分隔符分隔的输入元素。

参数

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

结果

A Collector ，它以相遇的顺序连接由指定的分隔符分隔的CharSequence元素

joining

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

返回一个 Collector ，它将按照指定的分隔符分隔的输入元素与指定的前缀和后缀进行连接。

参数

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

prefix - 在连接结果开始时使用的字符序列

suffix - 在结合结果结束时使用的字符序列

结果

A 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()收集器在用于多级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()收集器在多级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()操作，那根本就没有该部门的映射。

参数类型

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 - a 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 - a 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个值，平均计算中的除数将在23 ^53度饱和，导致额外的数值误差。

参数类型

T - 输入元素的类型

参数

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

结果

一个产生派生属性的算术平均值的 Collector

reducing

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

返回一个 Collector ，它使用提供的身份在指定的 BinaryOperator下执行其输入元素的减少。

API Note:

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 Note:

reducing()收集器在多级减少中使用时最有用， groupingBy或partitioningBy下游。 要简单地减少流，请改用Stream.reduce(BinaryOperator) 。

例如，给出Person的流，计算每个城市的最高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 - a 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 - a BinaryOperator<U>用于减少映射值

结果

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

结果

一个实现group-by操作的 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())));  

Implementation Note:

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

参数类型

T - 输入元素的类型

K - 键的类型

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

D - 下游减少的结果类型

参数

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

downstream - a 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对与给定键相关联的值执行缩减操作。 由收藏Map生产的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 - a Collector实现下游缩减

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

结果

一个实现级联组合操作的 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其中包含映射到分类函数下的关联键的输入元素。

对于返回的ConcurrentMap或List对象的类型，可变性或可序列化，或返回的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的类型，可变性或可序列性没有保证。

例如，计算城市名称排序的每个城市的人姓名集：

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

参数类型

T - 输入元素的类型

K - 键的类型

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

D - 下游减少的结果类型

参数

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

downstream - a 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生产的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实现了级联组合操作

另请参见：

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 Note:

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

参数类型

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

API Note:

如果分区没有元素，则通过调用下游收集器的供应商函数，然后应用整理器函数，获取结果图中的值。

参数类型

T - 输入元素的类型

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

D - 下游减少的结果类型

参数

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

downstream - a 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 - 产生值的映射函数

结果

一个 Collector ，其将元素收集到 Map其键和值是将映射函数应用于输入元素的结果

另请参见：

toMap(Function, Function, BinaryOperator) ， toMap(Function, Function, BinaryOperator, Supplier) ， toConcurrentMap(Function, Function)

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)

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返回的类型，可变性或可序列化没有保证。

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)