## 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 a 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,​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.