第四篇 JDK11 Collectors预置的收集器方法

豢龙先生

已于 2022-03-13 19:05:27 修改

阅读量868

点赞数

分类专栏： Java8实战（学习笔记）文章标签： java

于 2022-03-13 19:01:07 首次发布

本文链接：https://blog.csdn.net/sanjun333/article/details/123461208

版权

Java8实战（学习笔记）专栏收录该内容

4 篇文章 1 订阅

订阅专栏

java.util.stream.Collectors

修饰符和类型	方法	描述
`static <T> Collector<T,?,Double>`	`averagingDouble(ToDoubleFunction<? super T> mapper)`	返回求输入Double类型元素平均值的`Collector`
`static <T> Collector<T,?,Double>`	`averagingInt(ToIntFunction<? super T> mapper)`	返回求输入Interger类型元素平均值的`Collector`
`static <T> Collector<T,?,Double>`	`averagingLong(ToLongFunction<? super T> mapper)`	返回求输入Long类型元素平均值的`Collector`
`static <T,A,R,RR> Collector<T,A,RR>`	`collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)`	调整收集器在完成收集后应用额外的转换逻辑
`static <T> Collector<T,?,Long>`	`counting()`	返回一个接受T类型元素的`Collector`，用于统计T元素的个数
`static <T,A,R> Collector<T,?,R>`	`filtering(Predicate<? super T> predicate, Collector<? super T,A,R> downstream)`	通过对每个输入元素应用`Predicate`，使收集器适应于一个接受相同类型T的元素，并只在`Predicate`返回true时进行累积。
`static <T,U,A,R> Collector<T,?,R>`	`flatMapping(Function<? super T,? extends Stream<? extends U>> mapper,Collector<? super U,A,R> downstream)`	通过在累积之前对每个输入元素应用`Function`映射函数，将一个接受U类型元素的收集器调整为一个接受T类型元素。
`static <T,K> Collector<T,?,Map<K,List<T>>>`	`groupingBy(Function<? super T,? extends K> classifier)`	Returns a `Collector` implementing a "group by" operation on input elements of type `T`, grouping elements according to a classification function, and returning the results in a `Map`.
`static <T,K,D,A,M extendsMap<K,D>> Collector<T,?,M>`	`groupingBy(Function<? super T,? extends K> classifier,Supplier<M> mapFactory, Collector<? super T,A,D> downstream)`	Returns a `Collector` implementing a cascaded "group by" operation on input elements of type `T`, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream `Collector`.
`static <T,K,A,D> Collector<T,?,Map<K,D>>`	`groupingBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)`	Returns a `Collector` implementing a cascaded "group by" operation on input elements of type `T`, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream `Collector`.
`static <T,K> Collector<T,?,ConcurrentMap<K,List<T>>>`	`groupingByConcurrent(Function<? super T,? extends K> classifier)`	Returns a concurrent `Collector` implementing a "group by" operation on input elements of type `T`, grouping elements according to a classification function.
`static <T,K,A,D,M extendsConcurrentMap<K,D>> Collector<T,?,M>`	`groupingByConcurrent(Function<? super T,? extends K> classifier,Supplier<M> mapFactory, Collector<? super T,A,D> downstream)`	Returns a concurrent `Collector` implementing a cascaded "group by" operation on input elements of type `T`, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream `Collector`.
`static <T,K,A,D> Collector<T,?,ConcurrentMap<K,D>>`	`groupingByConcurrent(Function<? super T,? extends K> classifier,Collector<? super T,A,D> downstream)`	Returns a concurrent `Collector` implementing a cascaded "group by" operation on input elements of type `T`, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream `Collector`.
`staticCollector<CharSequence,?,String>`	`joining()`	Returns a `Collector` that concatenates the input elements into a `String`, in encounter order.
`staticCollector<CharSequence,?,String>`	`joining(CharSequence delimiter)`	Returns a `Collector` that concatenates the input elements, separated by the specified delimiter, in encounter order.
`staticCollector<CharSequence,?,String>`	`joining(CharSequence delimiter, CharSequence prefix,CharSequence suffix)`	Returns a `Collector` that concatenates the input elements, separated by the specified delimiter, with the specified prefix and suffix, in encounter order.
`static <T,U,A,R> Collector<T,?,R>`	`mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)`	Adapts a `Collector` accepting elements of type `U` to one accepting elements of type `T` by applying a mapping function to each input element before accumulation.
`static <T> Collector<T,?,Optional<T>>`	`maxBy(Comparator<? super T> comparator)`	Returns a `Collector` that produces the maximal element according to a given `Comparator`, described as an `Optional<T>`.
`static <T> Collector<T,?,Optional<T>>`	`minBy(Comparator<? super T> comparator)`	Returns a `Collector` that produces the minimal element according to a given `Comparator`, described as an `Optional<T>`.
`static <T> Collector<T,?,Map<Boolean,List<T>>>`	`partitioningBy(Predicate<? super T> predicate)`	Returns a `Collector` which partitions the input elements according to a `Predicate`, and organizes them into a `Map<Boolean, List<T>>`.
`static <T,D,A> Collector<T,?,Map<Boolean,D>>`	`partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)`	Returns a `Collector` which partitions the input elements according to a `Predicate`, reduces the values in each partition according to another `Collector`, and organizes them into a `Map<Boolean, D>` whose values are the result of the downstream reduction.
`static <T> Collector<T,?,Optional<T>>`	`reducing(BinaryOperator<T> op)`	Returns a `Collector` which performs a reduction of its input elements under a specified `BinaryOperator`.
`static <T> Collector<T,?,T>`	`reducing(T identity, BinaryOperator<T> op)`	Returns a `Collector` which performs a reduction of its input elements under a specified `BinaryOperator` using the provided identity.
`static <T,U> Collector<T,?,U>`	`reducing(U identity, Function<? super T,? extends U> mapper,BinaryOperator<U> op)`	Returns a `Collector` which performs a reduction of its input elements under a specified mapping function and `BinaryOperator`.
`static <T> Collector<T,?,DoubleSummaryStatistics>`	`summarizingDouble(ToDoubleFunction<? super T> mapper)`	Returns a `Collector` which applies an `double`-producing mapping function to each input element, and returns summary statistics for the resulting values.
`static <T> Collector<T,?,IntSummaryStatistics>`	`summarizingInt(ToIntFunction<? super T> mapper)`	Returns a `Collector` which applies an `int`-producing mapping function to each input element, and returns summary statistics for the resulting values.
`static <T> Collector<T,?,LongSummaryStatistics>`	`summarizingLong(ToLongFunction<? super T> mapper)`	Returns a `Collector` which applies an `long`-producing mapping function to each input element, and returns summary statistics for the resulting values.
`static <T> Collector<T,?,Double>`	`summingDouble(ToDoubleFunction<? super T> mapper)`	Returns a `Collector` that produces the sum of a double-valued function applied to the input elements.
`static <T> Collector<T,?,Integer>`	`summingInt(ToIntFunction<? super T> mapper)`	Returns a `Collector` that produces the sum of a integer-valued function applied to the input elements.
`static <T> Collector<T,?,Long>`	`summingLong(ToLongFunction<? super T> mapper)`	Returns a `Collector` that produces the sum of a long-valued function applied to the input elements.
`static <T,C extendsCollection<T>> Collector<T,?,C>`	`toCollection(Supplier<C> collectionFactory)`	Returns a `Collector` that accumulates the input elements into a new `Collection`, in encounter order.
`static <T,K,U> Collector<T,?,ConcurrentMap<K,U>>`	`toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)`	Returns a concurrent `Collector` that accumulates elements into a `ConcurrentMap` whose keys and values are the result of applying the provided mapping functions to the input elements.
`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)`	Returns a concurrent `Collector` that accumulates elements into a `ConcurrentMap` whose keys and values are the result of applying the provided mapping functions to the input elements.
`static <T,K,U,M extendsConcurrentMap<K,U>> Collector<T,?,M>`	`toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction,Supplier<M> mapFactory)`	Returns a concurrent `Collector` that accumulates elements into a `ConcurrentMap` whose keys and values are the result of applying the provided mapping functions to the input elements.
`static <T> Collector<T,?,List<T>>`	`toList()`	Returns a `Collector` that accumulates the input elements into a new `List`.
`static <T,K,U> Collector<T,?,Map<K,U>>`	`toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)`	Returns a `Collector` that accumulates elements into a `Map` whose keys and values are the result of applying the provided mapping functions to the input elements.
`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)`	Returns a `Collector` that accumulates elements into a `Map` whose keys and values are the result of applying the provided mapping functions to the input elements.
`static <T,K,U,M extendsMap<K,U>> Collector<T,?,M>`	`toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction,Supplier<M> mapFactory)`	Returns a `Collector` that accumulates elements into a `Map` whose keys and values are the result of applying the provided mapping functions to the input elements.
`static <T> Collector<T,?,Set<T>>`	`toSet()`	Returns a `Collector` that accumulates the input elements into a new `Set`.
`static <T> Collector<T,?,List<T>>`	`toUnmodifiableList()`	Returns a `Collector` that accumulates the input elements into an unmodifiable List in encounter order.
`static <T,K,U> Collector<T,?,Map<K,U>>`	`toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)`	Returns a `Collector` that accumulates the input elements into an unmodifiable Map, whose keys and values are the result of applying the provided mapping functions to the input elements.
`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)`	Returns a `Collector` that accumulates the input elements into an unmodifiable Map, whose keys and values are the result of applying the provided mapping functions to the input elements.
`static <T> Collector<T,?,Set<T>>`	`toUnmodifiableSet()`	Returns a `Collector` that accumulates the input elements into an unmodifiable Set.

豢龙先生

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
第四篇 JDK11 Collectors预置的收集器方法

java.util.stream.Collectors修饰符和类型方法描述 static <T>Collector<T,?,Double> averagingDouble(ToDoubleFunction<? super T>mapper) 返回求输入Double类型元素平均值的Collector static <T>Collector<T,?,Double> ...
复制链接

扫一扫