com.annimon.stream

Class Collectors

java.lang.Object

com.annimon.stream.Collectors

public final class Collectors
extends java.lang.Object

Common implementations of Collector interface.

See Also:

Collector

Method Summary

Modifier and Type	Method and Description
static <T> Collector<T,?,java.lang.Double>	averaging(Function<? super T,java.lang.Double> mapper) Deprecated. As of release 1.1.3, replaced by averagingDouble(com.annimon.stream.function.ToDoubleFunction)
static <T> Collector<T,?,java.lang.Double>	averagingDouble(ToDoubleFunction<? super T> mapper) Returns a Collector that calculates average of double-valued input elements.
static <T> Collector<T,?,java.lang.Double>	averagingInt(ToIntFunction<? super T> mapper) Returns a Collector that calculates average of integer-valued input elements.
static <T> Collector<T,?,java.lang.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,?,java.lang.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,?,java.util.Map<K,java.util.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,?,java.util.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 java.util.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<java.lang.CharSequence,?,java.lang.String>	joining() Returns a Collector that concatenates input elements into new string.
static Collector<java.lang.CharSequence,?,java.lang.String>	joining(java.lang.CharSequence delimiter) Returns a Collector that concatenates input elements into new string.
static Collector<java.lang.CharSequence,?,java.lang.String>	joining(java.lang.CharSequence delimiter, java.lang.CharSequence prefix, java.lang.CharSequence suffix) Returns a Collector that concatenates input elements into new string.
static Collector<java.lang.CharSequence,?,java.lang.String>	joining(java.lang.CharSequence delimiter, java.lang.CharSequence prefix, java.lang.CharSequence suffix, java.lang.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> Collector<T,?,java.util.Map<java.lang.Boolean,java.util.List<T>>>	partitioningBy(Predicate<? super T> predicate) Returns a Collector that performs partitioning operation according to a predicate.
static <T,D,A> Collector<T,?,java.util.Map<java.lang.Boolean,D>>	partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream) Returns a Collector that performs partitioning operation according to a predicate.
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,?,java.lang.Double>	summingDouble(ToDoubleFunction<? super T> mapper) Returns a Collector that summing double-valued input elements.
static <T> Collector<T,?,java.lang.Integer>	summingInt(ToIntFunction<? super T> mapper) Returns a Collector that summing integer-valued input elements.
static <T> Collector<T,?,java.lang.Long>	summingLong(ToLongFunction<? super T> mapper) Returns a Collector that summing long-valued input elements.
static <T,R1,R2,R> Collector<T,?,R>	teeing(Collector<? super T,?,R1> downstream1, Collector<? super T,?,R2> downstream2, BiFunction<? super R1,? super R2,R> merger) Returns a Collector that composites two collectors.
static <T,R extends java.util.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,?,java.util.List<T>>	toList() Returns a Collector that fills new List with input elements.
static <T,K> Collector<T,?,java.util.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,?,java.util.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> Collector<T,?,java.util.Map<K,V>>	toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction) Returns a Collector that fills new Map with input elements.
static <T,K,V,M extends java.util.Map<K,V>> Collector<T,?,M>	toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<M> mapFactory) Returns a Collector that fills new Map with input elements.
static <T,K,V,M extends java.util.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,?,java.util.Set<T>>	toSet() Returns a Collector that fills new Set with input elements.
static <T> Collector<T,?,java.util.List<T>>	toUnmodifiableList() Returns a Collector that fills new unmodifiable List with input elements.
static <T,K,V> Collector<T,?,java.util.Map<K,V>>	toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper) Returns a Collector that fills new unmodifiable Map with input elements.
static <T,K,V> Collector<T,?,java.util.Map<K,V>>	toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction) Returns a Collector that fills new unmodifiable Map with input elements.
static <T> Collector<T,?,java.util.Set<T>>	toUnmodifiableSet() Returns a Collector that fills new unmodifiable 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

@NotNull
public static <T,R extends java.util.Collection<T>> Collector<T,?,R> toCollection(@NotNull
                                                                                           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

@NotNull
public static <T> Collector<T,?,java.util.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

toUnmodifiableList

@NotNull
public static <T> Collector<T,?,java.util.List<T>> toUnmodifiableList()

Returns a Collector that fills new unmodifiable List with input elements. The returned Collector disallows nulls and throws NullPointerException if it is presented with a null value.

Type Parameters:

T - the type of the input elements

Returns:

a Collector

Since:

1.2.0

toSet

@NotNull
public static <T> Collector<T,?,java.util.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

toUnmodifiableSet

@NotNull
public static <T> Collector<T,?,java.util.Set<T>> toUnmodifiableSet()

Returns a Collector that fills new unmodifiable Set with input elements. The returned Collector disallows nulls and throws NullPointerException if it is presented with a null value. If elements contain duplicates, an arbitrary element of the duplicates is preserved.

Type Parameters:

T - the type of the input elements

Returns:

a Collector

Since:

1.2.0

toMap

@NotNull
public static <T,K> Collector<T,?,java.util.Map<K,T>> toMap(@NotNull
                                                                     Function<? super T,? extends K> keyMapper)

Returns a Collector that fills new Map with input elements. If the mapped keys contain duplicates, an IllegalStateException is thrown. Use toMap(Function, Function, BinaryOperator) to handle merging of the values.

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

See Also:

toMap(Function, Function, BinaryOperator)

toMap

@NotNull
public static <T,K,V> Collector<T,?,java.util.Map<K,V>> toMap(@NotNull
                                                                       Function<? super T,? extends K> keyMapper,
                                                                       @NotNull
                                                                       Function<? super T,? extends V> valueMapper)

Returns a Collector that fills new Map with input elements. If the mapped keys contain duplicates, an IllegalStateException is thrown. Use toMap(Function, Function, BinaryOperator) to handle merging of the values.

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

See Also:

toMap(Function, Function, BinaryOperator)

toMap

@NotNull
public static <T,K,V,M extends java.util.Map<K,V>> Collector<T,?,M> toMap(@NotNull
                                                                                   Function<? super T,? extends K> keyMapper,
                                                                                   @NotNull
                                                                                   Function<? super T,? extends V> valueMapper,
                                                                                   @NotNull
                                                                                   Supplier<M> mapFactory)

Returns a Collector that fills new Map with input elements. If the mapped keys contain duplicates, an IllegalStateException is thrown. Use toMap(Function, Function, BinaryOperator, Supplier) to handle merging of the values.

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

See Also:

toMap(Function, Function, BinaryOperator, Supplier)

toUnmodifiableMap

@NotNull
public static <T,K,V> Collector<T,?,java.util.Map<K,V>> toUnmodifiableMap(@NotNull
                                                                                   Function<? super T,? extends K> keyMapper,
                                                                                   @NotNull
                                                                                   Function<? super T,? extends V> valueMapper)

Returns a Collector that fills new unmodifiable Map with input elements. The returned Collector disallows null keys and values. If the mapped keys contain duplicates, an IllegalStateException is thrown, see toUnmodifiableMap(Function, Function, BinaryOperator).

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

Since:

1.2.0

See Also:

toUnmodifiableMap(Function, Function, BinaryOperator)

toMap

@NotNull
public static <T,K,V> Collector<T,?,java.util.Map<K,V>> toMap(@NotNull
                                                                       Function<? super T,? extends K> keyMapper,
                                                                       @NotNull
                                                                       Function<? super T,? extends V> valueMapper,
                                                                       @NotNull
                                                                       BinaryOperator<V> mergeFunction)

Returns a Collector that fills new Map with input elements. If the mapped keys contain duplicates, the value mapping function is applied to each equal element, and the results are merged using the provided merging function.

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

mergeFunction - a merge function, used to resolve collisions between values associated with the same key

Returns:

a Collector

Since:

1.2.0

toMap

@NotNull
public static <T,K,V,M extends java.util.Map<K,V>> Collector<T,?,M> toMap(@NotNull
                                                                                   Function<? super T,? extends K> keyMapper,
                                                                                   @NotNull
                                                                                   Function<? super T,? extends V> valueMapper,
                                                                                   @NotNull
                                                                                   BinaryOperator<V> mergeFunction,
                                                                                   @NotNull
                                                                                   Supplier<M> mapFactory)

Returns a Collector that fills new Map with input elements. If the mapped keys contain duplicates, the value mapping function is applied to each equal element, and the results are merged using the provided merging function.

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

mergeFunction - a merge function, used to resolve collisions between values associated with the same key

mapFactory - a supplier function that provides new Map

Returns:

a Collector

Since:

1.2.0

toUnmodifiableMap

@NotNull
public static <T,K,V> Collector<T,?,java.util.Map<K,V>> toUnmodifiableMap(@NotNull
                                                                                   Function<? super T,? extends K> keyMapper,
                                                                                   @NotNull
                                                                                   Function<? super T,? extends V> valueMapper,
                                                                                   @NotNull
                                                                                   BinaryOperator<V> mergeFunction)

Returns a Collector that fills new unmodifiable Map with input elements. The returned Collector disallows null keys and values.

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

mergeFunction - a merge function, used to resolve collisions between values associated with the same key

Returns:

a Collector

Since:

1.2.0

joining

@NotNull
public static Collector<java.lang.CharSequence,?,java.lang.String> joining()

Returns a Collector that concatenates input elements into new string.

Returns:

a Collector

joining

@NotNull
public static Collector<java.lang.CharSequence,?,java.lang.String> joining(@NotNull
                                                                                    java.lang.CharSequence delimiter)

Returns a Collector that concatenates input elements into new string.

Parameters:

delimiter - the delimiter between each element

Returns:

a Collector

joining

@NotNull
public static Collector<java.lang.CharSequence,?,java.lang.String> joining(@NotNull
                                                                                    java.lang.CharSequence delimiter,
                                                                                    @NotNull
                                                                                    java.lang.CharSequence prefix,
                                                                                    @NotNull
                                                                                    java.lang.CharSequence suffix)

Returns a Collector that concatenates input elements into new string.

Parameters:

delimiter - the delimiter between each element

prefix - the prefix of result

suffix - the suffix of result

Returns:

a Collector

joining

@NotNull
public static Collector<java.lang.CharSequence,?,java.lang.String> joining(@NotNull
                                                                                    java.lang.CharSequence delimiter,
                                                                                    @NotNull
                                                                                    java.lang.CharSequence prefix,
                                                                                    @NotNull
                                                                                    java.lang.CharSequence suffix,
                                                                                    @NotNull
                                                                                    java.lang.String emptyValue)

Returns a Collector that concatenates input elements into new string.

Parameters:

delimiter - the delimiter 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
 @NotNull
public static <T> Collector<T,?,java.lang.Double> averaging(@NotNull
                                                                                  Function<? super T,java.lang.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

@NotNull
public static <T> Collector<T,?,java.lang.Double> averagingInt(@NotNull
                                                                        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

@NotNull
public static <T> Collector<T,?,java.lang.Double> averagingLong(@NotNull
                                                                         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

@NotNull
public static <T> Collector<T,?,java.lang.Double> averagingDouble(@NotNull
                                                                           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

@NotNull
public static <T> Collector<T,?,java.lang.Integer> summingInt(@NotNull
                                                                       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

@NotNull
public static <T> Collector<T,?,java.lang.Long> summingLong(@NotNull
                                                                     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

@NotNull
public static <T> Collector<T,?,java.lang.Double> summingDouble(@NotNull
                                                                         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

@NotNull
public static <T> Collector<T,?,java.lang.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

@NotNull
public static <T> Collector<T,?,T> reducing(@Nullable
                                                     T identity,
                                                     @NotNull
                                                     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

@NotNull
public static <T,R> Collector<T,?,R> reducing(@Nullable
                                                       R identity,
                                                       @NotNull
                                                       Function<? super T,? extends R> mapper,
                                                       @NotNull
                                                       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

@NotNull
public static <T,A,R> Collector<T,?,R> filtering(@NotNull
                                                          Predicate<? super T> predicate,
                                                          @NotNull
                                                          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

@NotNull
public static <T,U,A,R> Collector<T,?,R> mapping(@NotNull
                                                          Function<? super T,? extends U> mapper,
                                                          @NotNull
                                                          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

@NotNull
public static <T,U,A,R> Collector<T,?,R> flatMapping(@NotNull
                                                              Function<? super T,? extends Stream<? extends U>> mapper,
                                                              @NotNull
                                                              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

@NotNull
public static <T,A,IR,OR> Collector<T,A,OR> collectingAndThen(@NotNull
                                                                       Collector<T,A,IR> c,
                                                                       @NotNull
                                                                       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

@NotNull
public static <T,K> Collector<T,?,java.util.Map<K,java.util.List<T>>> groupingBy(@NotNull
                                                                                          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

@NotNull
public static <T,K,A,D> Collector<T,?,java.util.Map<K,D>> groupingBy(@NotNull
                                                                              Function<? super T,? extends K> classifier,
                                                                              @NotNull
                                                                              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

@NotNull
public static <T,K,D,A,M extends java.util.Map<K,D>> Collector<T,?,M> groupingBy(@NotNull
                                                                                          Function<? super T,? extends K> classifier,
                                                                                          @NotNull
                                                                                          Supplier<M> mapFactory,
                                                                                          @NotNull
                                                                                          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)

partitioningBy

@NotNull
public static <T> Collector<T,?,java.util.Map<java.lang.Boolean,java.util.List<T>>> partitioningBy(@NotNull
                                                                                                            Predicate<? super T> predicate)

Returns a Collector that performs partitioning operation according to a predicate. The returned Map always contains mappings for both false and true keys.

Type Parameters:

T - the type of the input elements

Parameters:

predicate - a predicate used for classifying input elements

Returns:

a Collector

Since:

1.1.9

partitioningBy

@NotNull
public static <T,D,A> Collector<T,?,java.util.Map<java.lang.Boolean,D>> partitioningBy(@NotNull
                                                                                                Predicate<? super T> predicate,
                                                                                                @NotNull
                                                                                                Collector<? super T,A,D> downstream)

Returns a Collector that performs partitioning operation according to a predicate. The returned Map always contains mappings for both false and true keys.

Type Parameters:

T - the type of the input elements

D - the result type of downstream reduction

A - the accumulation type

Parameters:

predicate - a predicate used for classifying input elements

downstream - the collector of partitioned elements

Returns:

a Collector

Since:

1.1.9

teeing

@NotNull
public static <T,R1,R2,R> Collector<T,?,R> teeing(@NotNull
                                                           Collector<? super T,?,R1> downstream1,
                                                           @NotNull
                                                           Collector<? super T,?,R2> downstream2,
                                                           @NotNull
                                                           BiFunction<? super R1,? super R2,R> merger)

Returns a Collector that composites two collectors. Each element is processed by two specified collectors, then their results are merged using the merge function into the final result.

Type Parameters:

T - the type of the input elements

R1 - the result type of the first collector

R2 - the result type of the second collector

R - the type of the final result

Parameters:

downstream1 - the first collector

downstream2 - the second collector

merger - the function which merges two results into the single one

Returns:

a Collector

Since:

1.2.2