compact1, compact2, compact3

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	Method and Description
static <T> Collector<T,?,Double>	averagingDouble(ToDoubleFunction<? super T> mapper) 返回一个 Collector ，它产生应用于输入元素的双值函数的算术平均值。
static <T> Collector<T,?,Double>	averagingInt(ToIntFunction<? super T> mapper) 返回一个 Collector ，它产生应用于输入元素的整数值函数的算术平均值。
static <T> Collector<T,?,Double>	averagingLong(ToLongFunction<? super T> mapper) 返回一个 Collector ，它产生应用于输入元素的长值函数的算术平均值。
static <T,A,R,RR> Collector<T,A,RR>	collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher) 适应 Collector进行额外的整理转换。
static <T> Collector<T,?,Long>	counting() 返回 Collector类型的接受元件 T计数输入元件的数量。
static <T,K> Collector<T,?,Map<K,List<T>>>	groupingBy(Function<? super T,? extends K> classifier) 返回 Collector “由基团”上的类型的输入元件操作实现 T ，根据分类功能分组元素，并且在返回的结果 Map 。
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,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> Collector<T,?,ConcurrentMap<K,List<T>>>	groupingByConcurrent(Function<? super T,? extends K> classifier) 返回一个并发 Collector “由基团”上的类型的输入元件操作实现 T ，根据分类功能分组元素。
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 <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 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 ，它将按照指定的 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对输入元素进行 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对输入元素进行 Predicate ，根据另一个 Collector减少每个分区的值，并将其组织成 Map<Boolean, D> ，其值是下游缩减的结果。
static <T> Collector<T,?,Optional<T>>	reducing(BinaryOperator<T> op) 返回一个 Collector ，它在指定的 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下执行其输入元素的 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> mapSupplier) 返回一个并发的 Collector ，它将元素累加到一个 ConcurrentMap ，其键和值是将所提供的映射函数应用于输入元素的结果。
static <T> Collector<T,?,List<T>>	toList() 返回一个 Collector ，它将输入元素 List到一个新的 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> mapSupplier) 返回一个 Collector ，它将元素累加到一个 Map ，其键和值是将所提供的映射函数应用于输入元素的结果。
static <T> Collector<T,?,Set<T>>	toSet() 返回一个 Collector ，将输入元素 Set到一个新的 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 - 一个 Supplier ，返回一个新的，空的 Collection的适当类型

结果

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

toList

public static <T> Collector<T,?,List<T>> toList()

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

参数类型

T - 输入元素的类型

结果

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

toSet

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

返回一个Collector ，将输入元素Set到一个新的Set 。 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 ，以按照顺序将指定的 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 Note:

mapping()收集器在多级别缩减时最为有用，例如groupingBy或partitioningBy 。 例如，给出一个Person的流，以累积每个城市中的一组姓氏：

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

参数类型

T - 输入元素的类型

U - 下游收集器接受的元素类型

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

R - R结果类型

参数

mapper - 要应用于输入元素的函数

downstream - 将接受映射值的收集器

结果

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

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> people = people.stream().collect(collectingAndThen(toList(), Collections::unmodifiableList));  

参数类型

T - 输入元素的类型

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

R - 下游收集器的结果类型

RR - 结果 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 -一个 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 - a BinaryOperator<T>用于减少输入元素

结果

一个 Collector缩小操作的Collector

另请参见：

reducing(BinaryOperator) ， reducing(Object, Function, BinaryOperator)

reducing

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

返回一个Collector ，它在指定的Collector下执行其输入元素的BinaryOperator 。 结果被描述为Optional<T> 。

API Note:

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

例如，给出Person的流， Person每个城市的最高人数：

   Comparator<Person> byHeight = Comparator.comparing(Person::getHeight); Map<City, Person> tallestByCity = people.stream().collect(groupingBy(Person::getCity, reducing(BinaryOperator.maxBy(byHeight))));  

参数类型

T - 减少输入和输出的元素类型

参数

op - 一个 BinaryOperator<T>用于减少输入元素

结果

一个 Collector缩小操作的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下执行其输入元素的BinaryOperator 。 这是reducing(Object, BinaryOperator)的泛化 ，其允许在还原之前转换元素。

API Note:

的reducing()收集器是在多级降低使用时最有用的，下游groupingBy或partitioningBy 。 要在流上执行简单的map-reduce，请改用Stream.map(Function)和Stream.reduce(Object, BinaryOperator) 。

例如，给出一个Person的流， 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包含输入元件，其映射到分类函数下的相关联的密钥s。

对返回的Map或List对象的类型，可变性，可串行性或线程安全性没有Map 。

实现要求：

这产生的结果类似于：

   groupingBy(classifier, toList());  

Implementation Note:

返回的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 。

例如，要计算每个城市的一组姓氏：

   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 - D的结果类型

参数

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

downstream - 一个 Collector实现下游缩减

结果

一个 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 - D的结果类型

M -所得的类型 Map

参数

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

downstream - a Collector实现下游缩减

mapFactory - 一个函数，当被调用时，产生一个新的空的 Map所需的类型

结果

一个 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>>的键是从施加所述分类功能的输入元件，并且其相应的值是所得的值List包含输入元件，其映射到分类函数下的相关联的密钥s。

对返回的Map或List对象的类型，可变性或可序列性，或返回的List对象的线程安全性没有List 。

实现要求：

这产生的结果类似于：

   groupingByConcurrent(classifier, toList());  

参数类型

T - 输入元素的类型

K - 键的类型

参数

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

结果

一个并发的，无序的 Collector实现了group-by操作

另请参见：

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对与给定键相关联的值执行缩减Collector 。

这是一个concurrent和unordered收藏家。

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

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

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

参数类型

T - 输入元素的类型

K - 键的类型

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

D - 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对与给定键相关联的值执行缩减Collector 。 由ConcurrentMap生产的ConcurrentMap由提供的工厂功能创建。

这是一个concurrent和unordered收藏家。

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

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

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

参数类型

T - 输入元素的类型

K - 键的类型

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

D - D的结果类型

M -所得的类型 ConcurrentMap

参数

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

downstream - a 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对输入元素进行Predicate ，并将它们组织成Map<Boolean, List<T>> 。 Map返回的类型，可变性，可串行性或线程安全性没有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对输入元素进行Predicate ，根据另一个Collector减少每个分区中的值，并将其组织成Map<Boolean, D> ，其值是下游缩减的结果。

Map返回的类型，可变性，可串行性或线程安全性没有Map 。

参数类型

T - 输入元素的类型

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

D - 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) 。

API Note:

键或值作为输入元素是常见的。 在这种情况下，实用方法Function.identity()可能是有帮助的。 例如，以下产生一个Map映射学生到他们的平均成绩：

   Map<Student, Double> studentToGPA students.stream().collect(toMap(Functions.identity(), student -> computeGPA(student)));  

以下产生一个Map映射学生的唯一标识符：

   Map<String, Student> studentIdToStudent students.stream().collect(toMap(Student::getId, Functions.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) ），则值映射函数应用于每个相等的元素，并使用提供的合并函数合并结果。

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

返回一个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)

mapSupplier - 返回一个新的空的 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操作时将抛出IllegalStateException。 如果映射的密钥可能有重复，请改用toConcurrentMap(Function, Function, BinaryOperator) 。

API Note:

键或值作为输入元素是常见的。 在这种情况下，实用方法Function.identity()可能是有帮助的。 例如，以下产生一个Map映射学生到他们的平均成绩：

   Map<Student, Double> studentToGPA students.stream().collect(toMap(Functions.identity(), student -> computeGPA(student)));  

以下产生一个Map映射学生的唯一标识符：

   Map<String, Student> studentIdToStudent students.stream().collect(toConcurrentMap(Student::getId, Functions.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) ），则值映射函数应用于每个相等的元素，并使用提供的合并函数合并结果。

API Note:

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

   Map<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> mapSupplier)

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

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

这是一个concurrent和unordered收藏家。

参数类型

T - 输入元素的类型

K - 键映射功能的输出类型

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

M - 结果的类型 ConcurrentMap

参数

keyMapper - 产生密钥的映射函数

valueMapper - 产生值的映射函数

mergeFunction - 一个合并函数，用于解决与相同键相关联的值之间的冲突，提供给 Map.merge(Object, Object, BiFunction)

mapSupplier - 返回一个新的，空的 Map的函数，结果将被插入到该函数中

结果

一个并发的，无序的 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)