Uses of Interface java.util.stream.Collector (Java SE 26 & JDK 26)
Description: use: module: java.base, package: java.util.stream, interface: Collector

# Uses of Interface
java.util.stream.Collector

Packages that use Collector
Package
Description
java.util.stream
Classes to support functional-style operations on streams of elements, such as map-reduce transformations on collections.

- ## Uses of Collector in java.util.stream

  Methods in java.util.stream that return Collector
  Modifier and Type
  Method
  Description
  `static <T> Collector<T,?,Double>`
  Collectors.`averagingDouble(ToDoubleFunction<? super T> mapper)`
  Returns a `Collector` that produces the arithmetic mean of a double-valued function applied to the input elements.
  `static <T> Collector<T,?,Double>`
  Collectors.`averagingInt(ToIntFunction<? super T> mapper)`
  Returns a `Collector` that produces the arithmetic mean of an integer-valued function applied to the input elements.
  `static <T> Collector<T,?,Double>`
  Collectors.`averagingLong(ToLongFunction<? super T> mapper)`
  Returns a `Collector` that produces the arithmetic mean of a long-valued function applied to the input elements.
  `static <T,A,R,RR> Collector<T,A,RR>`
  Collectors.`collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)`
  Adapts a `Collector` to perform an additional finishing transformation.
  `static <T> Collector<T,?,Long>`
  Collectors.`counting()`
  Returns a `Collector` accepting elements of type `T` that counts the number of input elements.
  `static <T,A,R> Collector<T,?,R>`
  Collectors.`filtering(Predicate<? super T> predicate, Collector<? super T, A, R> downstream)`
  Adapts a `Collector` to one accepting elements of the same type `T` by applying the predicate to each input element and only accumulating if the predicate returns `true`.
  `static <T,U,A,R> Collector<T,?,R>`
  Collectors.`flatMapping(Function<? super T, ? extends Stream<? 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 flat mapping function to each input element before accumulation.
  `static <T,K> Collector<T, ?, Map<K,List<T>>>`
  Collectors.`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 extends Map<K,D>>
  Collector<T,?,M>`
  Collectors.`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>>`
  Collectors.`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>>>`
  Collectors.`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 extends ConcurrentMap<K,D>>
  Collector<T,?,M>`
  Collectors.`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>>`
  Collectors.`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`.
  `static Collector<CharSequence, ?, String>`
  Collectors.`joining()`
  Returns a `Collector` that concatenates the input elements into a `String`, in encounter order.
  `static Collector<CharSequence, ?, String>`
  Collectors.`joining(CharSequence delimiter)`
  Returns a `Collector` that concatenates the input elements, separated by the specified delimiter, in encounter order.
  `static Collector<CharSequence, ?, String>`
  Collectors.`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>`
  Collectors.`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>>`
  Collectors.`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>>`
  Collectors.`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,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)`
  Returns a new `Collector` described by the given `supplier`, `accumulator`, `combiner`, and `finisher` functions.
  `static <T,R> Collector<T,R,R>`
  Collector.`of(Supplier<R> supplier, BiConsumer<R,T> accumulator, BinaryOperator<R> combiner, Collector.Characteristics... characteristics)`
  Returns a new `Collector` described by the given `supplier`, `accumulator`, and `combiner` functions.
  `static <T> Collector<T, ?, Map<Boolean,List<T>>>`
  Collectors.`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>>`
  Collectors.`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>>`
  Collectors.`reducing(BinaryOperator<T> op)`
  Returns a `Collector` which performs a reduction of its input elements under a specified `BinaryOperator`.
  `static <T> Collector<T,?,T>`
  Collectors.`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>`
  Collectors.`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>`
  Collectors.`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>`
  Collectors.`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>`
  Collectors.`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>`
  Collectors.`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>`
  Collectors.`summingInt(ToIntFunction<? super T> mapper)`
  Returns a `Collector` that produces the sum of an integer-valued function applied to the input elements.
  `static <T> Collector<T,?,Long>`
  Collectors.`summingLong(ToLongFunction<? super T> mapper)`
  Returns a `Collector` that produces the sum of a long-valued function applied to the input elements.
  `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)`
  Returns a `Collector` that is a composite of two downstream collectors.
  `static <T, C extends Collection<T>>
  Collector<T,?,C>`
  Collectors.`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>>`
  Collectors.`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>>`
  Collectors.`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 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)`
  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>>`
  Collectors.`toList()`
  Returns a `Collector` that accumulates the input elements into a new `List`.
  `static <T,K,U> Collector<T,?,Map<K,U>>`
  Collectors.`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>>`
  Collectors.`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 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)`
  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>>`
  Collectors.`toSet()`
  Returns a `Collector` that accumulates the input elements into a new `Set`.
  `static <T> Collector<T,?,List<T>>`
  Collectors.`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>>`
  Collectors.`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>>`
  Collectors.`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>>`
  Collectors.`toUnmodifiableSet()`
  Returns a `Collector` that accumulates the input elements into an unmodifiable Set.
  Methods in java.util.stream with parameters of type Collector
  Modifier and Type
  Method
  Description
  `<R,A> R`
  Stream.`collect(Collector<? super T, A, R> collector)`
  Performs a mutable reduction operation on the elements of this stream using a `Collector`.
  `static <T,A,R,RR> Collector<T,A,RR>`
  Collectors.`collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)`
  Adapts a `Collector` to perform an additional finishing transformation.
  `static <T,A,R> Collector<T,?,R>`
  Collectors.`filtering(Predicate<? super T> predicate, Collector<? super T, A, R> downstream)`
  Adapts a `Collector` to one accepting elements of the same type `T` by applying the predicate to each input element and only accumulating if the predicate returns `true`.
  `static <T,U,A,R> Collector<T,?,R>`
  Collectors.`flatMapping(Function<? super T, ? extends Stream<? 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 flat mapping function to each input element before accumulation.
  `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)`
  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>>`
  Collectors.`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, 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)`
  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>>`
  Collectors.`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`.
  `static <T,U,A,R> Collector<T,?,R>`
  Collectors.`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,D,A> Collector<T, ?, Map<Boolean,D>>`
  Collectors.`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,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)`
  Returns a `Collector` that is a composite of two downstream collectors.