Collectors (Lightweight-Stream-API 1.1.5 API)

java.lang.Object
- com.annimon.stream.Collectors

```
public final class Collectors
extends Object
```
Common implementations of Collector interface.

See Also:

Collector

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T> Collector<T,?,Double>`	`averaging(Function<? super T,Double> mapper)` Deprecated. As of release 1.1.3, replaced by `averagingDouble(com.annimon.stream.function.ToDoubleFunction)`
`static <T> Collector<T,?,Double>`	`averagingDouble(ToDoubleFunction<? super T> mapper)` Returns a `Collector` that calculates average of double-valued input elements.
`static <T> Collector<T,?,Double>`	`averagingInt(ToIntFunction<? super T> mapper)` Returns a `Collector` that calculates average of integer-valued input elements.
`static <T> Collector<T,?,Double>`	`averagingLong(ToLongFunction<? super T> mapper)` Returns a `Collector` that calculates average of long-valued input elements.
`static <T,A,IR,OR> Collector<T,A,OR>`	`collectingAndThen(Collector<T,A,IR> c, Function<IR,OR> finisher)` Returns a `Collector` that performs additional transformation.
`static <T> Collector<T,?,Long>`	`counting()` Returns a `Collector` that counts the number of input elements.
`static <T,A,R> Collector<T,?,R>`	`filtering(Predicate<? super T> predicate, Collector<? super T,A,R> downstream)` Returns a `Collector` that filters input elements.
`static <T,U,A,R> Collector<T,?,R>`	`flatMapping(Function<? super T,? extends Stream<? extends U>> mapper, Collector<? super U,A,R> downstream)` Returns a `Collector` that performs flat-mapping before accumulation.
`static <T,K> Collector<T,?,Map<K,List<T>>>`	`groupingBy(Function<? super T,? extends K> classifier)` Returns a `Collector` that performs grouping operation by given classifier.
`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` that performs grouping operation by given classifier.
`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)` Returns a `Collector` that performs grouping operation by given classifier.
`static Collector<CharSequence,?,String>`	`joining()` Returns a `Collector` that concatenates input elements into new string.
`static Collector<CharSequence,?,String>`	`joining(CharSequence delimiter)` Returns a `Collector` that concatenates input elements into new string.
`static Collector<CharSequence,?,String>`	`joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)` Returns a `Collector` that concatenates input elements into new string.
`static Collector<CharSequence,?,String>`	`joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix, String emptyValue)` Returns a `Collector` that concatenates input elements into new string.
`static <T,U,A,R> Collector<T,?,R>`	`mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)` Returns a `Collector` that performs mapping before accumulation.
`static <T,R> Collector<T,?,R>`	`reducing(R identity, Function<? super T,? extends R> mapper, BinaryOperator<R> op)` Returns a `Collector` that reduces input elements.
`static <T> Collector<T,?,T>`	`reducing(T identity, BinaryOperator<T> op)` Returns a `Collector` that reduces input elements.
`static <T> Collector<T,?,Double>`	`summingDouble(ToDoubleFunction<? super T> mapper)` Returns a `Collector` that summing double-valued input elements.
`static <T> Collector<T,?,Integer>`	`summingInt(ToIntFunction<? super T> mapper)` Returns a `Collector` that summing integer-valued input elements.
`static <T> Collector<T,?,Long>`	`summingLong(ToLongFunction<? super T> mapper)` Returns a `Collector` that summing long-valued input elements.
`static <T,R extends Collection<T>> Collector<T,?,R>`	`toCollection(Supplier<R> collectionSupplier)` Returns a `Collector` that fills new `Collection`, provided by `collectionSupplier`, with input elements.
`static <T> Collector<T,?,List<T>>`	`toList()` Returns a `Collector` that fills new `List` with input elements.
`static <T,K> Collector<T,?,Map<K,T>>`	`toMap(Function<? super T,? extends K> keyMapper)` Returns a `Collector` that fills new `Map` with input elements.
`static <T,K,V> Collector<T,?,Map<K,V>>`	`toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)` Returns a `Collector` that fills new `Map` with input elements.
`static <T,K,V,M extends Map<K,V>> Collector<T,?,M>`	`toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Supplier<M> mapFactory)` Returns a `Collector` that fills new `Map` with input elements.
`static <T> Collector<T,?,Set<T>>`	`toSet()` Returns a `Collector` that fills new `Set` with input elements.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - toCollection
```
public static <T,R extends Collection<T>> Collector<T,?,R> toCollection(Supplier<R> collectionSupplier)
```
    Returns a Collector that fills new Collection, provided by collectionSupplier, with input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    R - the type of the resulting collection
    
    Parameters:
    
    collectionSupplier - a supplier function that provides new collection
    
    Returns:
    
    a Collector
  - toList
```
public static <T> Collector<T,?,List<T>> toList()
```
    Returns a Collector that fills new List with input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    Returns:
    
    a Collector
  - toSet
```
public static <T> Collector<T,?,Set<T>> toSet()
```
    Returns a Collector that fills new Set with input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    Returns:
    
    a Collector
  - toMap
```
public static <T,K> Collector<T,?,Map<K,T>> toMap(Function<? super T,? extends K> keyMapper)
```
    Returns a Collector that fills new Map with input elements.
    
    Type Parameters:
    
    T - the type of the input elements and the result type of value mapping function
    
    K - the result type of key mapping function
    
    Parameters:
    
    keyMapper - a mapping function to produce keys
    
    Returns:
    
    a Collector
    
    Since:
    
    1.1.3
  - toMap
```
public static <T,K,V> Collector<T,?,Map<K,V>> toMap(Function<? super T,? extends K> keyMapper,
                                                    Function<? super T,? extends V> valueMapper)
```
    Returns a Collector that fills new Map with input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    K - the result type of key mapping function
    
    V - the result type of value mapping function
    
    Parameters:
    
    keyMapper - a mapping function to produce keys
    
    valueMapper - a mapping function to produce values
    
    Returns:
    
    a Collector
  - toMap
```
public static <T,K,V,M extends Map<K,V>> Collector<T,?,M> toMap(Function<? super T,? extends K> keyMapper,
                                                                Function<? super T,? extends V> valueMapper,
                                                                Supplier<M> mapFactory)
```
    Returns a Collector that fills new Map with input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    K - the result type of key mapping function
    
    V - the result type of value mapping function
    
    M - the type of the resulting Map
    
    Parameters:
    
    keyMapper - a mapping function to produce keys
    
    valueMapper - a mapping function to produce values
    
    mapFactory - a supplier function that provides new Map
    
    Returns:
    
    a Collector
  - joining
```
public static Collector<CharSequence,?,String> joining()
```
    Returns a Collector that concatenates input elements into new string.
    
    Returns:
    
    a Collector
  - joining
```
public static Collector<CharSequence,?,String> joining(CharSequence delimiter)
```
    Returns a Collector that concatenates input elements into new string.
    
    Parameters:
    
    delimiter - the delimeter between each element
    
    Returns:
    
    a Collector
  - joining
```
public static Collector<CharSequence,?,String> joining(CharSequence delimiter,
                                                       CharSequence prefix,
                                                       CharSequence suffix)
```
    Returns a Collector that concatenates input elements into new string.
    
    Parameters:
    
    delimiter - the delimeter between each element
    
    prefix - the prefix of result
    
    suffix - the suffix of result
    
    Returns:
    
    a Collector
  - joining
```
public static Collector<CharSequence,?,String> joining(CharSequence delimiter,
                                                       CharSequence prefix,
                                                       CharSequence suffix,
                                                       String emptyValue)
```
    Returns a Collector that concatenates input elements into new string.
    
    Parameters:
    
    delimiter - the delimeter between each element
    
    prefix - the prefix of result
    
    suffix - the suffix of result
    
    emptyValue - the string which replaces empty element if exists
    
    Returns:
    
    a Collector
  - averaging
```
@Deprecated
public static <T> Collector<T,?,Double> averaging(Function<? super T,Double> mapper)
```
    Deprecated. As of release 1.1.3, replaced by averagingDouble(com.annimon.stream.function.ToDoubleFunction)
    
    Returns a Collector that calculates average of input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    Parameters:
    
    mapper - the mapping function which extracts value from element to calculate result
    
    Returns:
    
    a Collector
  - averagingInt
```
public static <T> Collector<T,?,Double> averagingInt(ToIntFunction<? super T> mapper)
```
    Returns a Collector that calculates average of integer-valued input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    Parameters:
    
    mapper - the mapping function which extracts value from element to calculate result
    
    Returns:
    
    a Collector
    
    Since:
    
    1.1.3
  - averagingLong
```
public static <T> Collector<T,?,Double> averagingLong(ToLongFunction<? super T> mapper)
```
    Returns a Collector that calculates average of long-valued input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    Parameters:
    
    mapper - the mapping function which extracts value from element to calculate result
    
    Returns:
    
    a Collector
    
    Since:
    
    1.1.3
  - averagingDouble
```
public static <T> Collector<T,?,Double> averagingDouble(ToDoubleFunction<? super T> mapper)
```
    Returns a Collector that calculates average of double-valued input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    Parameters:
    
    mapper - the mapping function which extracts value from element to calculate result
    
    Returns:
    
    a Collector
    
    Since:
    
    1.1.3
  - summingInt
```
public static <T> Collector<T,?,Integer> summingInt(ToIntFunction<? super T> mapper)
```
    Returns a Collector that summing integer-valued input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    Parameters:
    
    mapper - the mapping function which extracts value from element to calculate result
    
    Returns:
    
    a Collector
    
    Since:
    
    1.1.3
  - summingLong
```
public static <T> Collector<T,?,Long> summingLong(ToLongFunction<? super T> mapper)
```
    Returns a Collector that summing long-valued input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    Parameters:
    
    mapper - the mapping function which extracts value from element to calculate result
    
    Returns:
    
    a Collector
    
    Since:
    
    1.1.3
  - summingDouble
```
public static <T> Collector<T,?,Double> summingDouble(ToDoubleFunction<? super T> mapper)
```
    Returns a Collector that summing double-valued input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    Parameters:
    
    mapper - the mapping function which extracts value from element to calculate result
    
    Returns:
    
    a Collector
    
    Since:
    
    1.1.3
  - counting
```
public static <T> Collector<T,?,Long> counting()
```
    Returns a Collector that counts the number of input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    Returns:
    
    a Collector
  - reducing
```
public static <T> Collector<T,?,T> reducing(T identity,
                                            BinaryOperator<T> op)
```
    Returns a Collector that reduces input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    Parameters:
    
    identity - the initial value
    
    op - the operator to reduce elements
    
    Returns:
    
    a Collector
    
    See Also:
    
    reducing(java.lang.Object, com.annimon.stream.function.Function, com.annimon.stream.function.BinaryOperator)
  - reducing
```
public static <T,R> Collector<T,?,R> reducing(R identity,
                                              Function<? super T,? extends R> mapper,
                                              BinaryOperator<R> op)
```
    Returns a Collector that reduces input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    R - the type of the output elements
    
    Parameters:
    
    identity - the initial value
    
    mapper - the mapping function
    
    op - the operator to reduce elements
    
    Returns:
    
    a Collector
    
    See Also:
    
    reducing(java.lang.Object, com.annimon.stream.function.BinaryOperator)
  - filtering
```
public static <T,A,R> Collector<T,?,R> filtering(Predicate<? super T> predicate,
                                                 Collector<? super T,A,R> downstream)
```
    Returns a Collector that filters input elements.
    
    Type Parameters:
    
    T - the type of the input elements
    
    A - the accumulation type
    
    R - the type of the output elements
    
    Parameters:
    
    predicate - a predicate used to filter elements
    
    downstream - the collector of filtered elements
    
    Returns:
    
    a Collector
    
    Since:
    
    1.1.3
  - mapping
```
public static <T,U,A,R> Collector<T,?,R> mapping(Function<? super T,? extends U> mapper,
                                                 Collector<? super U,A,R> downstream)
```
    Returns a Collector that performs mapping before accumulation.
    
    Type Parameters:
    
    T - the type of the input elements
    
    U - the result type of mapping function
    
    A - the accumulation type
    
    R - the result type of collector
    
    Parameters:
    
    mapper - a function that performs mapping to input elements
    
    downstream - the collector of mapped elements
    
    Returns:
    
    a Collector
  - 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)
```
    Returns a Collector that performs flat-mapping before accumulation.
    
    Type Parameters:
    
    T - the type of the input elements
    
    U - the result type of flat-mapping function
    
    A - the accumulation type
    
    R - the result type of collector
    
    Parameters:
    
    mapper - a function that performs flat-mapping to input elements
    
    downstream - the collector of flat-mapped elements
    
    Returns:
    
    a Collector
    
    Since:
    
    1.1.3
  - collectingAndThen
```
public static <T,A,IR,OR> Collector<T,A,OR> collectingAndThen(Collector<T,A,IR> c,
                                                              Function<IR,OR> finisher)
```
    Returns a Collector that performs additional transformation.
    
    Type Parameters:
    
    T - the type of the input elements
    
    A - the accumulation type
    
    IR - the input type of the transformation function
    
    OR - the output type of the transformation function
    
    Parameters:
    
    c - the input Collector
    
    finisher - the final transformation function
    
    Returns:
    
    a Collector
  - groupingBy
```
public static <T,K> Collector<T,?,Map<K,List<T>>> groupingBy(Function<? super T,? extends K> classifier)
```
    Returns a Collector that performs grouping operation by given classifier.
    
    Type Parameters:
    
    T - the type of the input elements
    
    K - the type of the keys
    
    Parameters:
    
    classifier - the classifier function
    
    Returns:
    
    a Collector
    
    See Also:
    
    groupingBy(com.annimon.stream.function.Function, com.annimon.stream.Collector), groupingBy(com.annimon.stream.function.Function, com.annimon.stream.function.Supplier, com.annimon.stream.Collector)
  - 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)
```
    Returns a Collector that performs grouping operation by given classifier.
    
    Type Parameters:
    
    T - the type of the input elements
    
    K - the type of the keys
    
    A - the accumulation type
    
    D - the result type of downstream reduction
    
    Parameters:
    
    classifier - the classifier function
    
    downstream - the collector of mapped elements
    
    Returns:
    
    a Collector
    
    See Also:
    
    groupingBy(com.annimon.stream.function.Function), groupingBy(com.annimon.stream.function.Function, com.annimon.stream.function.Supplier, com.annimon.stream.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)
```
    Returns a Collector that performs grouping operation by given classifier.
    
    Type Parameters:
    
    T - the type of the input elements
    
    K - the type of the keys
    
    A - the accumulation type
    
    D - the result type of downstream reduction
    
    M - the type of the resulting Map
    
    Parameters:
    
    classifier - the classifier function
    
    mapFactory - a supplier function that provides new Map
    
    downstream - the collector of mapped elements
    
    Returns:
    
    a Collector
    
    See Also:
    
    groupingBy(com.annimon.stream.function.Function), groupingBy(com.annimon.stream.function.Function, com.annimon.stream.Collector)

Class Collectors

Method Summary

Methods inherited from class java.lang.Object

Method Detail

toCollection

toList

toSet

toMap

toMap

toMap

joining

joining

joining

joining

averaging

averagingInt

averagingLong

averagingDouble

summingInt

summingLong

summingDouble

counting

reducing

reducing

filtering

mapping

flatMapping

collectingAndThen

groupingBy

groupingBy

groupingBy