接口的使用
java.util.stream.Collector

使用 Collector 的包
包
描述
java.util.stream
支持对元素流进行函数式操作的类，例如对集合的 map-reduce 转换。

  • Collector 在 java.util.stream 中的用法

    java.util.stream 中返回 Collector 的方法
    修饰符和类型
    方法
    描述
    static <T> Collector<T,?,Double>
    Collectors.averagingDouble(ToDoubleFunction<? super T> mapper)
    返回一个 Collector，它产生应用于输入元素的双值函数的算术平均值。
    static <T> Collector<T,?,Double>
    Collectors.averagingInt(ToIntFunction<? super T> mapper)
    返回一个 Collector，它产生应用于输入元素的整数值函数的算术平均值。
    static <T> Collector<T,?,Double>
    Collectors.averagingLong(ToLongFunction<? super T> mapper)
    返回一个 Collector，它产生应用于输入元素的长值函数的算术平均值。
    static <T, A, R, RR>
    Collector<T,A,RR>
    Collectors.collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)
    调整 Collector 以执行额外的整理转换。
    static <T> Collector<T,?,Long>
    Collectors.counting()
    返回一个 Collector 接受类型为 T 的元素，它计算输入元素的数量。
    static <T, A, R> Collector<T,?,R>
    Collectors.filtering(Predicate<? super T> predicate, Collector<? super T,A,R> downstream)
    通过将谓词应用于每个输入元素并仅在谓词返回 true 时才累积，使 Collector 适应一个接受相同类型 T 的元素。
    static <T, U, A, R>
    Collector<T,?,R>
    Collectors.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>>>
    Collectors.groupingBy(Function<? super T,? extends K> classifier)
    返回一个 Collector 对类型为 T 的输入元素执行“分组依据”操作，根据分类函数对元素进行分组，并在 Map 中返回结果。
    static <T, K, D, A, M extends Map<K, D>>
    Collector<T,?,M>
    Collectors.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>>
    Collectors.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>>>
    Collectors.groupingByConcurrent(Function<? super T,? extends K> classifier)
    返回并发 Collector 对类型为 T 的输入元素执行“分组依据”操作，根据分类函数对元素进行分组。
    static <T, K, A, D, M extends ConcurrentMap<K, D>>
    Collector<T,?,M>
    Collectors.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>>
    Collectors.groupingByConcurrent(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)
    返回并发 Collector 对类型为 T 的输入元素实施级联“分组依据”操作，根据分类函数对元素进行分组，然后使用指定的下游 Collector 对与给定键关联的值执行缩减操作。
    static Collector<CharSequence,?,String>
    Collectors.joining()
    返回一个 Collector，它将输入元素按遇到顺序连接到一个 String 中。
    static Collector<CharSequence,?,String>
    Collectors.joining(CharSequence delimiter)
    返回一个 Collector，它按遇到顺序连接输入元素，由指定的定界符分隔。
    static Collector<CharSequence,?,String>
    Collectors.joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
    返回一个 Collector，它将输入元素连接在一起，由指定的定界符分隔，具有指定的前缀和后缀，按遇到的顺序排列。
    static <T, U, A, R>
    Collector<T,?,R>
    Collectors.mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)
    通过在累加之前对每个输入元素应用映射函数，使 Collector 接受类型为 U 的元素适应一个接受类型为 T 的元素。
    static <T> Collector<T,?,Optional<T>>
    Collectors.maxBy(Comparator<? super T> comparator)
    返回根据给定的 Comparator 生成最大元素的 Collector，描述为 Optional<T>。
    static <T> Collector<T,?,Optional<T>>
    Collectors.minBy(Comparator<? super T> comparator)
    返回根据给定的 Comparator 生成最小元素的 Collector，描述为 Optional<T>。
    static <T, A, R> Collector<T,A,R>
    Collector.of(Supplier<A> supplier, BiConsumer<A,T> accumulator, BinaryOperator<A> combiner, Function<A,R> finisher, Collector.Characteristics... characteristics)
    返回由给定的 supplier、accumulator、combiner 和 finisher 函数描述的新 Collector。
    static <T, R> Collector<T,R,R>
    Collector.of(Supplier<R> supplier, BiConsumer<R,T> accumulator, BinaryOperator<R> combiner, Collector.Characteristics... characteristics)
    返回由给定的 supplier、accumulator 和 combiner 函数描述的新 Collector。
    static <T> Collector<T,?,Map<Boolean,List<T>>>
    Collectors.partitioningBy(Predicate<? super T> predicate)
    返回一个 Collector，它根据 Predicate 对输入元素进行分区，并将它们组织成一个 Map<Boolean, List<T>>。
    static <T, D, A> Collector<T,?,Map<Boolean,D>>
    Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
    返回一个 Collector，它根据一个 Predicate 对输入元素进行分区，根据另一个 Collector 减少每个分区中的值，并将它们组织成一个 Map<Boolean, D>，其值是下游减少的结果。
    static <T> Collector<T,?,Optional<T>>
    Collectors.reducing(BinaryOperator<T> op)
    返回一个 Collector，它在指定的 BinaryOperator 下执行其输入元素的缩减。
    static <T> Collector<T,?,T>
    Collectors.reducing(T identity, BinaryOperator<T> op)
    返回一个 Collector，它使用提供的标识在指定的 BinaryOperator 下执行其输入元素的缩减。
    static <T, U> Collector<T,?,U>
    Collectors.reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op)
    返回一个 Collector，它在指定的map函数和 BinaryOperator 下执行其输入元素的缩减。
    static <T> Collector<T,?,DoubleSummaryStatistics>
    Collectors.summarizingDouble(ToDoubleFunction<? super T> mapper)
    返回一个 Collector，它将 double 生成的映射函数应用于每个输入元素，并返回结果值的汇总统计信息。
    static <T> Collector<T,?,IntSummaryStatistics>
    Collectors.summarizingInt(ToIntFunction<? super T> mapper)
    返回一个 Collector，它将 int 生成映射函数应用于每个输入元素，并返回结果值的汇总统计信息。
    static <T> Collector<T,?,LongSummaryStatistics>
    Collectors.summarizingLong(ToLongFunction<? super T> mapper)
    返回一个 Collector，它将 long 生成的映射函数应用于每个输入元素，并返回结果值的汇总统计信息。
    static <T> Collector<T,?,Double>
    Collectors.summingDouble(ToDoubleFunction<? super T> mapper)
    返回一个 Collector，它产生应用于输入元素的双值函数的总和。
    static <T> Collector<T,?,Integer>
    Collectors.summingInt(ToIntFunction<? super T> mapper)
    返回一个 Collector，它产生应用于输入元素的整数值函数的总和。
    static <T> Collector<T,?,Long>
    Collectors.summingLong(ToLongFunction<? super T> mapper)
    返回一个 Collector，它产生应用于输入元素的长值函数的总和。
    static <T, R1, R2, R>
    Collector<T,?,R>
    Collectors.teeing(Collector<? super T,?,R1> downstream1, Collector<? super T,?,R2> downstream2, BiFunction<? super R1,? super R2,R> merger)
    返回一个 Collector，它是两个下游收集器的组合。
    static <T, C extends Collection<T>>
    Collector<T,?,C>
    Collectors.toCollection(Supplier<C> collectionFactory)
    返回一个 Collector，它将输入元素累积到一个新的 Collection 中，按遇到的顺序排列。
    static <T, K, U> Collector<T,?,ConcurrentMap<K,U>>
    Collectors.toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
    返回并发的 Collector 将元素累积到 ConcurrentMap 中，其键和值是将提供的映射函数应用于输入元素的结果。
    static <T, K, U> Collector<T,?,ConcurrentMap<K,U>>
    Collectors.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>
    Collectors.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>>
    Collectors.toList()
    返回一个 Collector ，它将输入元素累积到一个新的 List 中。
    static <T, K, U> Collector<T,?,Map<K,U>>
    Collectors.toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
    返回一个 Collector，它将元素累积到一个 Map 中，其键和值是将提供的映射函数应用于输入元素的结果。
    static <T, K, U> Collector<T,?,Map<K,U>>
    Collectors.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>
    Collectors.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>>
    Collectors.toSet()
    返回一个 Collector ，它将输入元素累积到一个新的 Set 中。
    static <T> Collector<T,?,List<T>>
    Collectors.toUnmodifiableList()
    返回一个 Collector，它将输入元素按遇到顺序累积到 不可修改的列表 中。
    static <T, K, U> Collector<T,?,Map<K,U>>
    Collectors.toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
    返回一个 Collector ，它将输入元素累积到一个 不可修改的map 中，其键和值是将提供的映射函数应用于输入元素的结果。
    static <T, K, U> Collector<T,?,Map<K,U>>
    Collectors.toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)
    返回一个 Collector ，它将输入元素累积到一个 不可修改的map 中，其键和值是将提供的映射函数应用于输入元素的结果。
    static <T> Collector<T,?,Set<T>>
    Collectors.toUnmodifiableSet()
    返回将输入元素累积到 不可修改的集合 中的 Collector。
    java.util.stream 中的方法，参数类型为 Collector
    修饰符和类型
    方法
    描述
    <R, A> R
    Stream.collect(Collector<? super T,A,R> collector)
    使用 Collector 对此流的元素执行 可变减少 操作。
    static <T, A, R, RR>
    Collector<T,A,RR>
    Collectors.collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)
    调整 Collector 以执行额外的整理转换。
    static <T, A, R> Collector<T,?,R>
    Collectors.filtering(Predicate<? super T> predicate, Collector<? super T,A,R> downstream)
    通过将谓词应用于每个输入元素并仅在谓词返回 true 时才累积，使 Collector 适应一个接受相同类型 T 的元素。
    static <T, U, A, R>
    Collector<T,?,R>
    Collectors.flatMapping(Function<? super T,? extends Stream<? extends U>> mapper, Collector<? super U,A,R> downstream)
    通过在累加之前对每个输入元素应用平面映射函数，使 Collector 接受类型为 U 的元素适应一个接受类型为 T 的元素。
    static <T, K, D, A, M extends Map<K, D>>
    Collector<T,?,M>
    Collectors.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>>
    Collectors.groupingBy(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>
    Collectors.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>>
    Collectors.groupingByConcurrent(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)
    返回并发 Collector 对类型为 T 的输入元素实施级联“分组依据”操作，根据分类函数对元素进行分组，然后使用指定的下游 Collector 对与给定键关联的值执行缩减操作。
    static <T, U, A, R>
    Collector<T,?,R>
    Collectors.mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)
    通过在累加之前对每个输入元素应用映射函数，使 Collector 接受类型为 U 的元素适应一个接受类型为 T 的元素。
    static <T, D, A> Collector<T,?,Map<Boolean,D>>
    Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
    返回一个 Collector，它根据一个 Predicate 对输入元素进行分区，根据另一个 Collector 减少每个分区中的值，并将它们组织成一个 Map<Boolean, D>，其值是下游减少的结果。
    static <T, R1, R2, R>
    Collector<T,?,R>
    Collectors.teeing(Collector<? super T,?,R1> downstream1, Collector<? super T,?,R2> downstream2, BiFunction<? super R1,? super R2,R> merger)
    返回一个 Collector，它是两个下游收集器的组合。