模块  java.base
软件包  java.util.stream

Class Collectors

  • public final class Collectorsextends 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()
      返回类型为 T的 Collector接受元素，用于计算输入元素的数量。
      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 ，它以连接 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)
      通过在累积之前将映射函数应用于每个输入元素，将 T类型的 Collector接受元素调整为 U类型的一个接受元素。
      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下执行其输入元素的 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 。
      static <T> Collector<T,​?,​List<T>> toUnmodifiableList()
      返回 Collector ， 它按顺序将输入元素累积到 unmodifiable List中。
      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中 ，其键和值是将提供的映射函数应用于输入元素的结果。
      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中 ，其键和值是将提供的映射函数应用于输入元素的结果。
      static <T> Collector<T,​?,​Set<T>> toUnmodifiableSet()
      返回 Collector ，将输入元素累积到 unmodifiable Set中 。

    • 方法详细信息

      • 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 53到2 53范围内的所有连续整数。 如果管道具有超过2 53个值，则平均计算中的除数将饱和为2 53 ，从而导致额外的数值误差。
        参数类型
        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)