Package org.eclipse.collections.impl.collector

Class Collectors2

java.lang.Object

org.eclipse.collections.impl.collector.Collectors2

public final class Collectors2
extends Object

A set of Collectors for Eclipse Collections types and algorithms.

Includes converter Collectors to{Immutable}{Sorted}{List/Set/Bag/Map/BiMap/Multimap}.
Includes Collectors for select, reject, partition.
Includes Collectors for collect, collect{Boolean/Byte/Char/Short/Int/Float/Long/Double}.
Includes Collectors for makeString, zip, chunk.
Includes Collectors for sumBy{Int/Float/Long/Double}.

Use these Collectors with @RichIterable.reduceInPlace(Collector) and @Stream.collect(Collector).

Since:

8.0

Method Summary

Modifier and Type	Method	Description
static <T> Collector<T,?,MutableList<MutableList<T>>>	chunk(int size)	Partitions elements in fixed size chunks.
static <T,V,R extends Collection<V>> Collector<T,?,R>	collect(Function<? super T,? extends V> function, Supplier<R> supplier)	Returns a new collection with the results of applying the specified function on each element of the source collection.
static <T,R extends MutableBooleanCollection> Collector<T,?,R>	collectBoolean(BooleanFunction<? super T> function, Supplier<R> supplier)	Returns a new MutableBooleanCollection with the results of applying the specified BooleanFunction on each element of the source.
static <T,R extends MutableByteCollection> Collector<T,?,R>	collectByte(ByteFunction<? super T> function, Supplier<R> supplier)	Returns a new MutableByteCollection with the results of applying the specified ByteFunction on each element of the source.
static <T,R extends MutableCharCollection> Collector<T,?,R>	collectChar(CharFunction<? super T> function, Supplier<R> supplier)	Returns a new MutableCharCollection with the results of applying the specified CharFunction on each element of the source.
static <T,R extends MutableDoubleCollection> Collector<T,?,R>	collectDouble(DoubleFunction<? super T> function, Supplier<R> supplier)	Returns a new MutableDoubleCollection with the results of applying the specified DoubleFunction on each element of the source.
static <T,R extends MutableFloatCollection> Collector<T,?,R>	collectFloat(FloatFunction<? super T> function, Supplier<R> supplier)	Returns a new MutableFloatCollection with the results of applying the specified FloatFunction on each element of the source.
static <T,R extends MutableIntCollection> Collector<T,?,R>	collectInt(IntFunction<? super T> function, Supplier<R> supplier)	Returns a new MutableIntCollection with the results of applying the specified IntFunction on each element of the source.
static <T,R extends MutableLongCollection> Collector<T,?,R>	collectLong(LongFunction<? super T> function, Supplier<R> supplier)	Returns a new MutableLongCollection with the results of applying the specified LongFunction on each element of the source.
static <T,R extends MutableShortCollection> Collector<T,?,R>	collectShort(ShortFunction<? super T> function, Supplier<R> supplier)	Returns a new MutableShortCollection with the results of applying the specified ShortFunction on each element of the source.
static <T,P,V,R extends Collection<V>> Collector<T,?,R>	collectWith(Function2<? super T,? super P,? extends V> function, P parameter, Supplier<R> supplier)	Returns a new collection with the results of applying the specified function on each element of the source collection with the specified parameter.
static <T,V,R extends Collection<V>> Collector<T,?,R>	flatCollect(Function<? super T,? extends Iterable<V>> function, Supplier<R> supplier)	The method flatCollect is a special case of collect(Function, Supplier).
static <T,K,R extends MutableMultimap<K,T>> Collector<T,?,R>	groupBy(Function<? super T,? extends K> groupBy, Supplier<R> supplier)	Returns the elements as an MutableMultimap grouping each element using the specified groupBy Function.
static <T,K,V,R extends MutableMultimap<K,V>> Collector<T,?,R>	groupByAndCollect(Function<? super T,? extends K> groupBy, Function<? super T,? extends V> valueFunction, Supplier<R> supplier)	Returns the elements as an MutableMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.
static <T> Collector<T,?,String>	makeString()	Returns a String composed of elements separated by ", ".
static <T> Collector<T,?,String>	makeString(CharSequence separator)	Returns a String composed of elements separated by the specified separator.
static <T> Collector<T,?,String>	makeString(CharSequence start, CharSequence separator, CharSequence end)	Returns a String composed of elements separated by the specified separator and beginning with start String and ending with end String.
static <T,R extends PartitionMutableCollection<T>> Collector<T,?,R>	partition(Predicate<? super T> predicate, Supplier<R> supplier)	Returns all elements of the stream split into a PartitionMutableCollection after evaluating the predicate.
static <T,P,R extends PartitionMutableCollection<T>> Collector<T,?,R>	partitionWith(Predicate2<? super T,? super P> predicate, P parameter, Supplier<R> supplier)	Returns all elements of the stream split into a PartitionMutableCollection after evaluating the predicate.
static <T,R extends Collection<T>> Collector<T,?,R>	reject(Predicate<? super T> predicate, Supplier<R> supplier)	Returns all elements of the stream that return false when evaluating the predicate.
static <T,P,R extends Collection<T>> Collector<T,?,R>	rejectWith(Predicate2<? super T,? super P> predicate, P parameter, Supplier<R> supplier)	Returns all elements of the stream that return false when evaluating the predicate with the parameter.
static <T,R extends Collection<T>> Collector<T,?,R>	select(Predicate<? super T> predicate, Supplier<R> supplier)	Returns all elements of the stream that return true when evaluating the predicate.
static <T,P,R extends Collection<T>> Collector<T,?,R>	selectWith(Predicate2<? super T,? super P> predicate, P parameter, Supplier<R> supplier)	Returns all elements of the stream that return true when evaluating the predicate with the parameter.
static <T,V> Collector<T,?,MutableMap<V,BigDecimal>>	sumByBigDecimal(Function<? super T,? extends V> groupBy, Function<? super T,BigDecimal> function)	Groups and sums the values using the two specified functions.
static <T,V> Collector<T,?,MutableMap<V,BigInteger>>	sumByBigInteger(Function<? super T,? extends V> groupBy, Function<? super T,BigInteger> function)	Groups and sums the values using the two specified functions.
static <T,V> Collector<T,?,MutableObjectDoubleMap<V>>	sumByDouble(Function<? super T,? extends V> groupBy, DoubleFunction<? super T> function)	Groups and sums the values using the two specified functions.
static <T,V> Collector<T,?,MutableObjectDoubleMap<V>>	sumByFloat(Function<? super T,? extends V> groupBy, FloatFunction<? super T> function)	Groups and sums the values using the two specified functions.
static <T,V> Collector<T,?,MutableObjectLongMap<V>>	sumByInt(Function<? super T,? extends V> groupBy, IntFunction<? super T> function)	Groups and sums the values using the two specified functions.
static <T,V> Collector<T,?,MutableObjectLongMap<V>>	sumByLong(Function<? super T,? extends V> groupBy, LongFunction<? super T> function)	Groups and sums the values using the two specified functions.
static <T> Collector<T,?,SummaryStatistics<T>>	summarizing(ImmutableList<IntFunction<? super T>> intFunctions, ImmutableList<LongFunction<? super T>> longFunctions, ImmutableList<DoubleFunction<? super T>> doubleFunctions)	Returns a SummaryStatistics with results for int, long and double functions calculated for each element in the Stream or Collection this Collector is applied to.
static <T> Collector<T,?,BigDecimalSummaryStatistics>	summarizingBigDecimal(Function<? super T,BigDecimal> function)	Returns a BigDecimalSummaryStatistics applying the specified function to each element of the stream or collection.
static <T> Collector<T,?,BigIntegerSummaryStatistics>	summarizingBigInteger(Function<? super T,BigInteger> function)	Returns a BigIntegerSummaryStatistics applying the specified function to each element of the stream or collection.
static <T> Collector<T,?,BigDecimal>	summingBigDecimal(Function<? super T,BigDecimal> function)	Returns a BigDecimal sum applying the specified function to each element of the stream or collection.
static <T> Collector<T,?,BigInteger>	summingBigInteger(Function<? super T,BigInteger> function)	Returns a BigInteger sum applying the specified function to each element of the stream or collection.
static <T> Collector<T,?,MutableBag<T>>	toBag()	Returns the elements as a MutableBag.
static <T,K> Collector<T,?,MutableBagMultimap<K,T>>	toBagMultimap(Function<? super T,? extends K> groupBy)	Returns the elements as an MutableBagMultimap grouping each element using the specified groupBy Function.
static <T,K,V> Collector<T,?,MutableBagMultimap<K,V>>	toBagMultimap(Function<? super T,? extends K> groupBy, Function<? super T,? extends V> valueFunction)	Returns the elements as an MutableBagMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.
static <T,K,V> Collector<T,?,MutableBiMap<K,V>>	toBiMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)	Returns the elements as a MutableBiMap applying the keyFunction and valueFunction to each element.
static <T> Collector<T,?,ImmutableBag<T>>	toImmutableBag()	Returns the elements as an ImmutableBag.
static <T,K> Collector<T,?,ImmutableBagMultimap<K,T>>	toImmutableBagMultimap(Function<? super T,? extends K> groupBy)	Returns the elements as an ImmutableBagMultimap grouping each element using the specified groupBy Function.
static <T,K,V> Collector<T,?,ImmutableBagMultimap<K,V>>	toImmutableBagMultimap(Function<? super T,? extends K> groupBy, Function<? super T,? extends V> valueFunction)	Returns the elements as an ImmutableBagMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.
static <T,K,V> Collector<T,?,ImmutableBiMap<K,V>>	toImmutableBiMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)	Returns the elements as an ImmutableBiMap applying the keyFunction and valueFunction to each element.
static <T> Collector<T,?,ImmutableList<T>>	toImmutableList()	Returns the elements as an ImmutableList.
static <T,K> Collector<T,?,ImmutableListMultimap<K,T>>	toImmutableListMultimap(Function<? super T,? extends K> groupBy)	Returns the elements as an ImmutableListMultimap grouping each element using the specified groupBy Function.
static <T,K,V> Collector<T,?,ImmutableListMultimap<K,V>>	toImmutableListMultimap(Function<? super T,? extends K> groupBy, Function<? super T,? extends V> valueFunction)	Returns the elements as an ImmutableListMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.
static <T,K,V> Collector<T,?,ImmutableMap<K,V>>	toImmutableMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)	Returns the elements as an ImmutableMap applying the keyFunction and valueFunction to each element.
static <T> Collector<T,?,ImmutableSet<T>>	toImmutableSet()	Returns the elements as an ImmutableSet.
static <T,K> Collector<T,?,ImmutableSetMultimap<K,T>>	toImmutableSetMultimap(Function<? super T,? extends K> groupBy)	Returns the elements as an ImmutableSetMultimap grouping each element using the specified groupBy Function.
static <T,K,V> Collector<T,?,ImmutableSetMultimap<K,V>>	toImmutableSetMultimap(Function<? super T,? extends K> groupBy, Function<? super T,? extends V> valueFunction)	Returns the elements as an ImmutableSetMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.
static <T> Collector<T,?,ImmutableSortedBag<T>>	toImmutableSortedBag()	Returns the elements as an ImmutableSortedBag.
static <T> Collector<T,?,ImmutableSortedBag<T>>	toImmutableSortedBag(Comparator<? super T> comparator)	Returns the elements as an ImmutableSortedBag using the specified comparator.
static <T> Collector<T,?,ImmutableList<T>>	toImmutableSortedList()	Returns the elements as an ImmutableList that has been sorted.
static <T> Collector<T,?,ImmutableList<T>>	toImmutableSortedList(Comparator<? super T> comparator)	Returns the elements as an ImmutableList that has been sorted using the specified comparator.
static <T> Collector<T,?,ImmutableSortedSet<T>>	toImmutableSortedSet()	Returns the elements as an ImmutableSortedSet.
static <T> Collector<T,?,ImmutableSortedSet<T>>	toImmutableSortedSet(Comparator<? super T> comparator)	Returns the elements as an ImmutableSortedSet using the specified comparator.
static <T> Collector<T,?,ImmutableStack<T>>	toImmutableStack()	Returns the elements as an ImmutableStack.
static <T> Collector<T,?,MutableList<T>>	toList()	Returns the elements as a MutableList.
static <T,K> Collector<T,?,MutableListMultimap<K,T>>	toListMultimap(Function<? super T,? extends K> groupBy)	Returns the elements as an MutableListMultimap grouping each element using the specified groupBy Function.
static <T,K,V> Collector<T,?,MutableListMultimap<K,V>>	toListMultimap(Function<? super T,? extends K> groupBy, Function<? super T,? extends V> valueFunction)	Returns the elements as an MutableListMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.
static <T,K,V> Collector<T,?,MutableMap<K,V>>	toMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)	Returns the elements as a MutableMap applying the keyFunction and valueFunction to each element.
static <T> Collector<T,?,MutableSet<T>>	toSet()	Returns the elements as a MutableSet.
static <T,K> Collector<T,?,MutableSetMultimap<K,T>>	toSetMultimap(Function<? super T,? extends K> groupBy)	Returns the elements as an MutableSetMultimap grouping each element using the specified groupBy Function.
static <T,K,V> Collector<T,?,MutableSetMultimap<K,V>>	toSetMultimap(Function<? super T,? extends K> groupBy, Function<? super T,? extends V> valueFunction)	Returns the elements as an MutableSetMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.
static <T> Collector<T,?,MutableSortedBag<T>>	toSortedBag()	Returns the elements as a MutableSortedBag.
static <T> Collector<T,?,MutableSortedBag<T>>	toSortedBag(Comparator<? super T> comparator)	Returns the elements as a MutableSortedBag using the specified comparator.
static <T,V extends Comparable<? super V>> Collector<T,?,MutableSortedBag<T>>	toSortedBagBy(Function<? super T,? extends V> function)	Returns the elements as a MutableSortedBag using the specified function.
static <T> Collector<T,?,MutableList<T>>	toSortedList()	Returns the elements as a MutableList that has been sorted.
static <T> Collector<T,?,MutableList<T>>	toSortedList(Comparator<? super T> comparator)	Returns the elements as a MutableList that has been sorted using the specified comparator.
static <T,V extends Comparable<? super V>> Collector<T,?,MutableList<T>>	toSortedListBy(Function<? super T,? extends V> function)	Returns the elements as a MutableList that has been sorted using the specified comparator.
static <T> Collector<T,?,MutableSortedSet<T>>	toSortedSet()	Returns the elements as a MutableSortedSet.
static <T> Collector<T,?,MutableSortedSet<T>>	toSortedSet(Comparator<? super T> comparator)	Returns the elements as a MutableSortedSet using the specified comparator.
static <T,V extends Comparable<? super V>> Collector<T,?,MutableSortedSet<T>>	toSortedSetBy(Function<? super T,? extends V> function)	Returns the elements as a MutableSortedSet using the specified function to compare each element.
static <T> Collector<T,?,MutableStack<T>>	toStack()	Returns the elements as a MutableStack.
static <T,S> Collector<T,?,MutableList<Pair<T,S>>>	zip(Iterable<S> other)	Returns a MutableList formed from this stream of elements and another Iterable by combining corresponding elements in pairs.
static <T> Collector<T,?,MutableList<ObjectIntPair<T>>>	zipWithIndex()	Returns a MutableList of pairs formed from this stream of elements its indices.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

makeString

public static <T> Collector<T,?,String> makeString()

Returns a String composed of elements separated by ", ".

Examples:

System.out.println(Interval.oneTo(5).stream().collect(Collectors2.makeString()));
System.out.println(Interval.oneTo(5).reduceInPlace(Collectors2.makeString()));

Prints:

 1, 2, 3, 4, 5
 1, 2, 3, 4, 5
 

Equivalent to using @RichIterable.makeString()

System.out.println(Interval.oneTo(5).makeString());

makeString

public static <T> Collector<T,?,String> makeString(CharSequence separator)

Returns a String composed of elements separated by the specified separator.

Examples:

System.out.println(Interval.oneTo(5).stream().collect(Collectors2.makeString("")));
System.out.println(Interval.oneTo(5).reduceInPlace(Collectors2.makeString("")));

Prints:

 12345
 12345
 

Equivalent to using @RichIterable.makeString(String)

System.out.println(Interval.oneTo(5).makeString(""));

makeString

public static <T> Collector<T,?,String> makeString(CharSequence start,
                                                   CharSequence separator,
                                                   CharSequence end)

Returns a String composed of elements separated by the specified separator and beginning with start String and ending with end String.

Examples:

System.out.println(Interval.oneTo(5).stream().collect(Collectors2.makeString("[", ":", "]")));
System.out.println(Interval.oneTo(5).reduceInPlace(Collectors2.makeString("[", ":", "]")));

Prints:

 [1:2:3:4:5]
 [1:2:3:4:5]
 

Equivalent to using @RichIterable.makeString(String, String, String)}

System.out.println(Interval.oneTo(5).makeString("[", ":", "]"));

toList

public static <T> Collector<T,?,MutableList<T>> toList()

Returns the elements as a MutableList.

Examples:

MutableList<Integer> numbers1 = Interval.oneTo(5).stream().collect(Collectors2.toList());
MutableList<Integer> numbers2 = Interval.oneTo(5).reduceInPlace(Collectors2.toList());

Equivalent to using @RichIterable.toList()}

MutableList<Integer> numbers = Interval.oneTo(5).toList();

toImmutableList

public static <T> Collector<T,?,ImmutableList<T>> toImmutableList()

Returns the elements as an ImmutableList.

Examples:

ImmutableList<Integer> numbers1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableList());
ImmutableList<Integer> numbers2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableList());

Equivalent to using @RichIterable.toList() followed by: @MutableList.toImmutable().

ImmutableList<Integer> numbers = Interval.oneTo(5).toList().toImmutable();

toSet

public static <T> Collector<T,?,MutableSet<T>> toSet()

Returns the elements as a MutableSet.

Examples:

MutableSet<Integer> set1 = Interval.oneTo(5).stream().collect(Collectors2.toSet());
MutableSet<Integer> set2 =Interval.oneTo(5).reduceInPlace(Collectors2.toSet());

Equivalent to using @RichIterable.toSet()}

MutableSet<Integer> set = Interval.oneTo(5).toSet();

toImmutableSet

public static <T> Collector<T,?,ImmutableSet<T>> toImmutableSet()

Returns the elements as an ImmutableSet.

Examples:

ImmutableSet<Integer> set1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSet());
ImmutableSet<Integer> set2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSet());

Equivalent to using @RichIterable.toSet() followed by: @MutableSet.toImmutable().

ImmutableSet<Integer> set = Interval.oneTo(5).toSet().toImmutable();

toSortedSet

public static <T> Collector<T,?,MutableSortedSet<T>> toSortedSet()

Returns the elements as a MutableSortedSet.

Examples:

MutableSortedSet<Integer> set1 = Interval.oneTo(5).stream().collect(Collectors2.toSortedSet());
MutableSortedSet<Integer> set2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSortedSet());

Equivalent to using @RichIterable.toSortedSet()}.

MutableSortedSet<Integer> set = Interval.oneTo(5).toSortedSet();

toImmutableSortedSet

public static <T> Collector<T,?,ImmutableSortedSet<T>> toImmutableSortedSet()

Returns the elements as an ImmutableSortedSet.

Examples:

ImmutableSortedSet<Integer> set1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSortedSet());
ImmutableSortedSet<Integer> set2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSortedSet());

Equivalent to using @RichIterable.toSortedSet() followed by: @MutableSortedSet.toImmutable().

ImmutableSortedSet<Integer> set = Interval.oneTo(5).toSortedSet().toImmutable();

toSortedSet

public static <T> Collector<T,?,MutableSortedSet<T>> toSortedSet(Comparator<? super T> comparator)

Returns the elements as a MutableSortedSet using the specified comparator.

Examples:

MutableSortedSet<Integer> set1 = Interval.oneTo(5).stream().collect(Collectors2.toSortedSet(Comparator.naturalOrder()));
MutableSortedSet<Integer> set2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSortedSet(Comparator.naturalOrder()));

Equivalent to using @RichIterable.toSortedSet(Comparator).

MutableSortedSet<Integer> set = Interval.oneTo(5).toSortedSet(Comparator.naturalOrder());

toSortedSetBy

public static <T,V extends Comparable<? super V>> Collector<T,?,MutableSortedSet<T>> toSortedSetBy(Function<? super T,? extends V> function)

Returns the elements as a MutableSortedSet using the specified function to compare each element.

Examples:

MutableSortedSet<Integer> set1 = Interval.oneTo(5).stream().collect(Collectors2.toSortedSetBy(Object::toString));
MutableSortedSet<Integer> set2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSortedSetBy(Object::toString));

Equivalent to using @RichIterable.toSortedSetBy(Function).

MutableSortedSet<Integer> set = Interval.oneTo(5).toSortedSetBy(Object::toString);

toImmutableSortedSet

public static <T> Collector<T,?,ImmutableSortedSet<T>> toImmutableSortedSet(Comparator<? super T> comparator)

Returns the elements as an ImmutableSortedSet using the specified comparator.

Examples:

ImmutableSortedSet<Integer> set1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSortedSet(Comparator.naturalOrder()));
ImmutableSortedSet<Integer> set2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSortedSet(Comparator.naturalOrder()));

Equivalent to using @RichIterable.toSortedSet(Comparator) followed by: @MutableSortedSet.toImmutable().

ImmutableSortedSet<Integer> set = Interval.oneTo(5).toSortedSet(Comparator.naturalOrder()).toImmutable();

toBag

public static <T> Collector<T,?,MutableBag<T>> toBag()

Returns the elements as a MutableBag.

Examples:

MutableBag<Integer> bag1 = Interval.oneTo(5).stream().collect(Collectors2.toBag());
MutableBag<Integer> bag2 = Interval.oneTo(5).reduceInPlace(Collectors2.toBag());

Equivalent to using @RichIterable.toBag()}

MutableBag<Integer> bag = Interval.oneTo(5).toBag();

toImmutableBag

public static <T> Collector<T,?,ImmutableBag<T>> toImmutableBag()

Returns the elements as an ImmutableBag.

Examples:

ImmutableBag<Integer> bag1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableBag());
ImmutableBag<Integer> bag2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableBag());

Equivalent to using @RichIterable.toBag() followed by: @MutableBag.toImmutable().

ImmutableBag<Integer> bag = Interval.oneTo(5).toBag().toImmutable();

toSortedList

public static <T> Collector<T,?,MutableList<T>> toSortedList()

Returns the elements as a MutableList that has been sorted.

Examples:

MutableList<Integer> list1 = Interval.oneTo(5).stream().collect(Collectors2.toSortedList());
MutableList<Integer> list2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSortedList());

Equivalent to using @RichIterable.toSortedList()}

MutableList<Integer> list = Interval.oneTo(5).toSortedList();

toImmutableSortedList

public static <T> Collector<T,?,ImmutableList<T>> toImmutableSortedList()

Returns the elements as an ImmutableList that has been sorted.

Examples:

ImmutableList<Integer> list1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSortedList());
ImmutableList<Integer> list2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSortedList());

Equivalent to using @RichIterable.toSortedList() followed by: @MutableList.toImmutable().

ImmutableList<Integer> list = Interval.oneTo(5).toSortedList().toImmutable();

toSortedList

public static <T> Collector<T,?,MutableList<T>> toSortedList(Comparator<? super T> comparator)

Returns the elements as a MutableList that has been sorted using the specified comparator.

Examples:

MutableList<Integer> list1 = Interval.oneTo(5).stream().collect(Collectors2.toSortedList(Comparators.naturalOrder()));
MutableList<Integer> list2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSortedList(Comparators.naturalOrder()));

Equivalent to using @RichIterable.toSortedList(Comparator)}

MutableList<Integer> list = Interval.oneTo(5).toSortedList(Comparators.naturalOrder());

toSortedListBy

public static <T,V extends Comparable<? super V>> Collector<T,?,MutableList<T>> toSortedListBy(Function<? super T,? extends V> function)

Returns the elements as a MutableList that has been sorted using the specified comparator.

Examples:

MutableList<Integer> list1 = Interval.oneTo(5).stream().collect(Collectors2.toSortedListBy(Object::toString));
MutableList<Integer> list2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSortedListBy(Object::toString));

Equivalent to using @RichIterable.toSortedListBy(Function)}

MutableList<Integer> list = Interval.oneTo(5).toSortedListBy(Object::toString);

toImmutableSortedList

public static <T> Collector<T,?,ImmutableList<T>> toImmutableSortedList(Comparator<? super T> comparator)

Returns the elements as an ImmutableList that has been sorted using the specified comparator.

Examples:

ImmutableList<Integer> list1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSortedList(Comparator.naturalOrder()));
ImmutableList<Integer> list2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSortedList(Comparator.naturalOrder()));

Equivalent to using @RichIterable.toSortedList(Comparator) followed by: @MutableList.toImmutable().

ImmutableList<Integer> list = Interval.oneTo(5).toSortedList(Comparator.naturalOrder()).toImmutable();

toSortedBag

public static <T> Collector<T,?,MutableSortedBag<T>> toSortedBag()

Returns the elements as a MutableSortedBag.

Examples:

MutableSortedBag<Integer> bag1 = Interval.oneTo(5).stream().collect(Collectors2.toSortedBag());
MutableSortedBag<Integer> bag2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSortedBag());

Equivalent to using @RichIterable.toSortedBag()}

MutableSortedBag<Integer> bag = Interval.oneTo(5).toSortedBag();

toImmutableSortedBag

public static <T> Collector<T,?,ImmutableSortedBag<T>> toImmutableSortedBag()

Returns the elements as an ImmutableSortedBag.

Examples:

ImmutableSortedBag<Integer> bag1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSortedBag());
ImmutableSortedBag<Integer> bag2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSortedBag());

Equivalent to using @RichIterable.toSortedBag() followed by: @MutableList.toImmutable().

ImmutableSortedBag<Integer> bag = Interval.oneTo(5).toSortedBag().toImmutable();

toSortedBag

public static <T> Collector<T,?,MutableSortedBag<T>> toSortedBag(Comparator<? super T> comparator)

Returns the elements as a MutableSortedBag using the specified comparator.

Examples:

MutableSortedBag<Integer> bag1 = Interval.oneTo(5).stream().collect(Collectors2.toSortedBag(Comparators.naturalOrder()));
MutableSortedBag<Integer> bag2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSortedBag(Comparators.naturalOrder()));

Equivalent to using @RichIterable.toSortedBag(Comparator)

MutableSortedBag<Integer> bag = Interval.oneTo(5).toSortedBag(Comparators.naturalOrder());

toSortedBagBy

public static <T,V extends Comparable<? super V>> Collector<T,?,MutableSortedBag<T>> toSortedBagBy(Function<? super T,? extends V> function)

Returns the elements as a MutableSortedBag using the specified function.

Examples:

MutableSortedBag<Integer> bag1 = Interval.oneTo(5).stream().collect(Collectors2.toSortedBagBy(Object::toString));
MutableSortedBag<Integer> bag2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSortedBagBy(Object::toString));

Equivalent to using @RichIterable.toSortedBagBy(Function)}

MutableSortedBag<Integer> bag = Interval.oneTo(5).toSortedBagBy(Object::toString);

toImmutableSortedBag

public static <T> Collector<T,?,ImmutableSortedBag<T>> toImmutableSortedBag(Comparator<? super T> comparator)

Returns the elements as an ImmutableSortedBag using the specified comparator.

Examples:

ImmutableSortedBag<Integer> bag1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSortedBag(Comparator.naturalOrder()));
ImmutableSortedBag<Integer> bag1 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSortedBag(Comparator.naturalOrder()));

Equivalent to using @RichIterable.toSortedBag(Comparator) followed by: @MutableBag.toImmutable().

ImmutableSortedBag<Integer> bag = Interval.oneTo(5).toSortedBag(Comparator.naturalOrder()).toImmutable();

toStack

public static <T> Collector<T,?,MutableStack<T>> toStack()

Returns the elements as a MutableStack.

Examples:

MutableStack<Integer> stack1 = Interval.oneTo(5).stream().collect(Collectors2.toStack());
MutableStack<Integer> stack2 = Interval.oneTo(5).reduceInPlace(Collectors2.toStack());

Equivalent to using @OrderedIterable.toStack()}

MutableStack<Integer> stack = Interval.oneTo(5).toList().toStack();

toImmutableStack

public static <T> Collector<T,?,ImmutableStack<T>> toImmutableStack()

Returns the elements as an ImmutableStack.

Examples:

ImmutableStack<Integer> stack1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableStack());
ImmutableStack<Integer> stack2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableStack());

Equivalent to using @OrderedIterable.toStack() followed by: @StackIterable.toImmutable()}

ImmutableStack<Integer> stack = Interval.oneTo(5).toList().toStack().toImmutable();

toBiMap

public static <T,K,V> Collector<T,?,MutableBiMap<K,V>> toBiMap(Function<? super T,? extends K> keyFunction,
                                                               Function<? super T,? extends V> valueFunction)

Returns the elements as a MutableBiMap applying the keyFunction and valueFunction to each element.

Examples:

BiMap<Integer, String> biMap1 = Interval.oneTo(5).stream().collect(Collectors2.toBiMap(Functions.identity(), Object::toString));
BiMap<Integer, String> biMap1 = Interval.oneTo(5).reduceInPlace(Collectors2.toBiMap(Functions.identity(), Object::toString));

toImmutableBiMap

public static <T,K,V> Collector<T,?,ImmutableBiMap<K,V>> toImmutableBiMap(Function<? super T,? extends K> keyFunction,
                                                                          Function<? super T,? extends V> valueFunction)

Returns the elements as an ImmutableBiMap applying the keyFunction and valueFunction to each element.

Examples:

MutableBiMap<Integer, String> biMap1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableBiMap(Functions.identity(), Object::toString));
MutableBiMap<Integer, String> biMap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableBiMap(Functions.identity(), Object::toString));

toMap

public static <T,K,V> Collector<T,?,MutableMap<K,V>> toMap(Function<? super T,? extends K> keyFunction,
                                                           Function<? super T,? extends V> valueFunction)

Returns the elements as a MutableMap applying the keyFunction and valueFunction to each element.

Examples:

MutableMap<Integer, String> map1 = Interval.oneTo(5).stream().collect(Collectors2.toMap(Functions.identity(), Object::toString));
MutableMap<Integer, String> map2 = Interval.oneTo(5).reduceInPlace(Collectors2.toMap(Functions.identity(), Object::toString));

Equivalent to using @RichIterable.toMap(Function, Function)

MutableMap<Integer, String> map = Interval.oneTo(5).toMap(Functions.identity(), Object::toString);

toImmutableMap

public static <T,K,V> Collector<T,?,ImmutableMap<K,V>> toImmutableMap(Function<? super T,? extends K> keyFunction,
                                                                      Function<? super T,? extends V> valueFunction)

Returns the elements as an ImmutableMap applying the keyFunction and valueFunction to each element.

Examples:

ImmutableMap<Integer, String> map1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableMap(Functions.identity(), Object::toString));
ImmutableMap<Integer, String> map2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableMap(Functions.identity(), Object::toString));

Equivalent to using @RichIterable.toMap(Function, Function)

ImmutableMap<Integer, String> map = Interval.oneTo(5).toMap(Functions.identity(), Object::toString).toImmutable();

groupBy

public static <T,K,R extends MutableMultimap<K,T>> Collector<T,?,R> groupBy(Function<? super T,? extends K> groupBy,
                                                                            Supplier<R> supplier)

Returns the elements as an MutableMultimap grouping each element using the specified groupBy Function.

Examples:

MutableListMultimap<String, Integer> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.groupBy(Object::toString, Multimaps.mutable.list::empty));
MutableListMultimap<String, Integer> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.groupBy(Object::toString, Multimaps.mutable.list::empty));

Equivalent to using @RichIterable.groupBy(Function, MutableMultimap)

MutableListMultimap<String, Integer> multimap = Interval.oneTo(5).groupBy(Object::toString, Multimaps.mutable.list.empty());

groupByAndCollect

public static <T,K,V,R extends MutableMultimap<K,V>> Collector<T,?,R> groupByAndCollect(Function<? super T,? extends K> groupBy,
                                                                                        Function<? super T,? extends V> valueFunction,
                                                                                        Supplier<R> supplier)

Returns the elements as an MutableMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.

Examples:

MutableListMultimap<String, String> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.groupByAndCollect(Object::toString, Object::toString, Multimaps.mutable.list::empty));
MutableListMultimap<String, String> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.groupByAndCollect(Object::toString, Object::toString, Multimaps.mutable.list::empty));

toListMultimap

public static <T,K> Collector<T,?,MutableListMultimap<K,T>> toListMultimap(Function<? super T,? extends K> groupBy)

Returns the elements as an MutableListMultimap grouping each element using the specified groupBy Function.

Examples:

MutableListMultimap<String, Integer> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.toListMultimap(Object::toString));
MutableListMultimap<String, Integer> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toListMultimap(Object::toString));

toListMultimap

public static <T,K,V> Collector<T,?,MutableListMultimap<K,V>> toListMultimap(Function<? super T,? extends K> groupBy,
                                                                             Function<? super T,? extends V> valueFunction)

Returns the elements as an MutableListMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.

Examples:

MutableListMultimap<String, String> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.toListMultimap(Object::toString, Object::toString));
MutableListMultimap<String, String> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toListMultimap(Object::toString, Object::toString));

toSetMultimap

public static <T,K> Collector<T,?,MutableSetMultimap<K,T>> toSetMultimap(Function<? super T,? extends K> groupBy)

Returns the elements as an MutableSetMultimap grouping each element using the specified groupBy Function.

Examples:

MutableSetMultimap<String, Integer> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.toSetMultimap(Object::toString));
MutableSetMultimap<String, Integer> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSetMultimap(Object::toString));

toSetMultimap

public static <T,K,V> Collector<T,?,MutableSetMultimap<K,V>> toSetMultimap(Function<? super T,? extends K> groupBy,
                                                                           Function<? super T,? extends V> valueFunction)

Returns the elements as an MutableSetMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.

Examples:

MutableSetMultimap<String, String> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.toSetMultimap(Object::toString, Object::toString));
MutableSetMultimap<String, String> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSetMultimap(Object::toString, Object::toString));

toBagMultimap

public static <T,K> Collector<T,?,MutableBagMultimap<K,T>> toBagMultimap(Function<? super T,? extends K> groupBy)

Returns the elements as an MutableBagMultimap grouping each element using the specified groupBy Function.

Examples:

MutableBagMultimap<String, Integer> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.toBagMultimap(Object::toString));
MutableBagMultimap<String, Integer> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toBagMultimap(Object::toString));

toBagMultimap

public static <T,K,V> Collector<T,?,MutableBagMultimap<K,V>> toBagMultimap(Function<? super T,? extends K> groupBy,
                                                                           Function<? super T,? extends V> valueFunction)

Returns the elements as an MutableBagMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.

Examples:

MutableBagMultimap<String, String> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.toBagMultimap(Object::toString, Object::toString));
MutableBagMultimap<String, String> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toBagMultimap(Object::toString, Object::toString));

toImmutableListMultimap

public static <T,K> Collector<T,?,ImmutableListMultimap<K,T>> toImmutableListMultimap(Function<? super T,? extends K> groupBy)

Returns the elements as an ImmutableListMultimap grouping each element using the specified groupBy Function.

Examples:

ImmutableListMultimap<String, Integer> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableListMultimap(Object::toString));
ImmutableListMultimap<String, Integer> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableListMultimap(Object::toString));

toImmutableListMultimap

public static <T,K,V> Collector<T,?,ImmutableListMultimap<K,V>> toImmutableListMultimap(Function<? super T,? extends K> groupBy,
                                                                                        Function<? super T,? extends V> valueFunction)

Returns the elements as an ImmutableListMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.

Examples:

ImmutableListMultimap<String, String> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableListMultimap(Object::toString, Object::toString));
ImmutableListMultimap<String, String> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableListMultimap(Object::toString, Object::toString));

toImmutableSetMultimap

public static <T,K> Collector<T,?,ImmutableSetMultimap<K,T>> toImmutableSetMultimap(Function<? super T,? extends K> groupBy)

Returns the elements as an ImmutableSetMultimap grouping each element using the specified groupBy Function.

Examples:

ImmutableSetMultimap<String, Integer> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSetMultimap(Object::toString));
ImmutableSetMultimap<String, Integer> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSetMultimap(Object::toString));

toImmutableSetMultimap

public static <T,K,V> Collector<T,?,ImmutableSetMultimap<K,V>> toImmutableSetMultimap(Function<? super T,? extends K> groupBy,
                                                                                      Function<? super T,? extends V> valueFunction)

Returns the elements as an ImmutableSetMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.

Examples:

ImmutableSetMultimap<String, String> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSetMultimap(Object::toString, Object::toString));
ImmutableSetMultimap<String, String> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSetMultimap(Object::toString, Object::toString));

toImmutableBagMultimap

public static <T,K> Collector<T,?,ImmutableBagMultimap<K,T>> toImmutableBagMultimap(Function<? super T,? extends K> groupBy)

Returns the elements as an ImmutableBagMultimap grouping each element using the specified groupBy Function.

Examples:

ImmutableBagMultimap<String, Integer> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableBagMultimap(Object::toString));
ImmutableBagMultimap<String, Integer> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableBagMultimap(Object::toString));

toImmutableBagMultimap

public static <T,K,V> Collector<T,?,ImmutableBagMultimap<K,V>> toImmutableBagMultimap(Function<? super T,? extends K> groupBy,
                                                                                      Function<? super T,? extends V> valueFunction)

Returns the elements as an ImmutableBagMultimap grouping each element using the specified groupBy Function and converting each element to the value returned by applying the specified Function valueFunction.

Examples:

ImmutableBagMultimap<String, String> multimap1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableBagMultimap(Object::toString, Object::toString));
ImmutableBagMultimap<String, String> multimap2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableBagMultimap(Object::toString, Object::toString));

chunk

public static <T> Collector<T,?,MutableList<MutableList<T>>> chunk(int size)

Partitions elements in fixed size chunks.

Examples:

MutableList<MutableList<Integer>> chunks1 = Interval.oneTo(10).stream().collect(Collectors2.chunk(2));
MutableList<MutableList<Integer>> chunks2 = Interval.oneTo(10).reduceInPlace(Collectors2.chunk(2));

Equivalent to using @RichIterable.chunk(int)

LazyIterable<RichIterable<Integer>> chunks = Interval.oneTo(10).chunk(2);

zip

public static <T,S> Collector<T,?,MutableList<Pair<T,S>>> zip(Iterable<S> other)

Returns a MutableList formed from this stream of elements and another Iterable by combining corresponding elements in pairs.

If one of the two Iterables is longer than the other, its remaining elements are ignored.

Examples:

MutableList<Pair<Integer, Integer>> zipped1 = Interval.oneTo(10).stream().collect(Collectors2.zip(Interval.oneTo(10)));
MutableList<Pair<Integer, Integer>> zipped2 = Interval.oneTo(10).reduceInPlace(Collectors2.zip(Interval.oneTo(10)));

Equivalent to using @RichIterable.zip(Iterable)

LazyIterable<Pair<Integer, Integer>> zip = Interval.oneTo(10).zip(Interval.oneTo(10));

zipWithIndex

public static <T> Collector<T,?,MutableList<ObjectIntPair<T>>> zipWithIndex()

Returns a MutableList of pairs formed from this stream of elements its indices.

Examples:

MutableList<ObjectIntPair<Integer>> zipWithIndex1 = Interval.oneTo(10).stream().collect(Collectors2.zipWithIndex());
MutableList<ObjectIntPair<Integer>> zipWithIndex2 = Interval.oneTo(10).reduceInPlace(Collectors2.zipWithIndex());

Equivalent to using @RichIterable.zipWithIndex()

LazyIterable<Pair<Integer, Integer>> zipWithIndex = Interval.oneTo(10).zipWithIndex();

sumByInt

public static <T,V> Collector<T,?,MutableObjectLongMap<V>> sumByInt(Function<? super T,? extends V> groupBy,
                                                                    IntFunction<? super T> function)

Groups and sums the values using the two specified functions.

Examples:

MutableObjectLongMap<Integer> sumBy1 = Interval.oneTo(10).stream().collect(Collectors2.sumByInt(each -> Integer.valueOf(each % 2), Integer::intValue));
MutableObjectLongMap<Integer> sumBy2 = Interval.oneTo(10).reduceInPlace(Collectors2.sumByInt(each -> Integer.valueOf(each % 2), Integer::intValue));

Equivalent to using @RichIterable.sumByInt(Function, IntFunction)

ObjectLongMap<Integer> sumBy = Interval.oneTo(10).sumByInt(each -> Integer.valueOf(each % 2), Integer::intValue));

sumByLong

public static <T,V> Collector<T,?,MutableObjectLongMap<V>> sumByLong(Function<? super T,? extends V> groupBy,
                                                                     LongFunction<? super T> function)

Groups and sums the values using the two specified functions.

Examples:

MutableObjectLongMap<Long> sumBy1 = Interval.oneTo(10).stream().collect(Collectors2.sumByLong(each -> Long.valueOf(each % 2), Integer::longValue));
MutableObjectLongMap<Long> sumBy2 = Interval.oneTo(10).reduceInPlace(Collectors2.sumByLong(each -> Long.valueOf(each % 2), Integer::longValue));

Equivalent to using @RichIterable.sumByLong(Function, LongFunction)

ObjectLongMap<Long> sumBy = Interval.oneTo(10).sumByLong(each -> Long.valueOf(each % 2), Integer::longValue));

sumByFloat

public static <T,V> Collector<T,?,MutableObjectDoubleMap<V>> sumByFloat(Function<? super T,? extends V> groupBy,
                                                                        FloatFunction<? super T> function)

Groups and sums the values using the two specified functions.

Examples:

MutableObjectDoubleMap<Integer> sumBy1 = Interval.oneTo(10).stream().collect(Collectors2.sumByFloat(each -> ((int)each % 2), Integer::floatValue));
MutableObjectDoubleMap<Integer> sumBy2 = Interval.oneTo(10).reduceInPlace(Collectors2.sumByFloat(each -> ((int)each % 2), Integer::floatValue));

Equivalent to using @RichIterable.sumByFloat(Function, FloatFunction)

ObjectDoubleMap<Integer> sumBy = Interval.oneTo(10).sumByFloat(each -> ((int)each % 2), Integer::floatValue));

sumByDouble

public static <T,V> Collector<T,?,MutableObjectDoubleMap<V>> sumByDouble(Function<? super T,? extends V> groupBy,
                                                                         DoubleFunction<? super T> function)

Groups and sums the values using the two specified functions.

Examples:

MutableObjectDoubleMap<Integer> sumBy1 = Interval.oneTo(10).stream().collect(Collectors2.sumByDouble(each -> ((int)each % 2), Integer::doubleValue));
MutableObjectDoubleMap<Integer> sumBy2 = Interval.oneTo(10).reduceInPlace(Collectors2.sumByDouble(each -> ((int)each % 2), Integer::doubleValue));

Equivalent to using @RichIterable.sumByDouble(Function, DoubleFunction)

ObjectDoubleMap<Integer> sumBy = Interval.oneTo(10).sumByDouble(each -> ((int)each % 2), Integer::doubleValue));

sumByBigDecimal

public static <T,V> Collector<T,?,MutableMap<V,BigDecimal>> sumByBigDecimal(Function<? super T,? extends V> groupBy,
                                                                            Function<? super T,BigDecimal> function)

Groups and sums the values using the two specified functions.

Examples:

MutableMap<Integer, BigDecimal> sumBy1 = Interval.oneTo(10).stream().collect(Collectors2.sumByBigDecimal(each -> (each.intValue() % 2), BigDecimal::new));
MutableMap<Integer, BigDecimal> sumBy2 = Interval.oneTo(10).reduceInPlace(Collectors2.sumByBigDecimal(each -> (each.intValue() % 2), BigDecimal::new));

Equivalent to using @Iterate.sumByBigDecimal(Iterable, Function, Function)

MutableMap<Integer, BigDecimal> sumBy = Iterate.sumByBigDecimal(Interval.oneTo(10), each -> (each.intValue() % 2), BigDecimal::new));

Since:

8.1

sumByBigInteger

public static <T,V> Collector<T,?,MutableMap<V,BigInteger>> sumByBigInteger(Function<? super T,? extends V> groupBy,
                                                                            Function<? super T,BigInteger> function)

Groups and sums the values using the two specified functions.

Examples:

MutableMap<Integer, BigInteger> sumBy1 = Interval.oneTo(10).stream().collect(Collectors2.sumByBigInteger(each -> (each.intValue() % 2), each -> BigInteger.valueOf(each.longValue())));
MutableMap<Integer, BigInteger> sumBy2 = Interval.oneTo(10).reduceInPlace(Collectors2.sumByBigInteger(each -> (each.intValue() % 2), each -> BigInteger.valueOf(each.longValue())));

Equivalent to using @Iterate.sumByBigInteger(Iterable, Function, Function)

MutableMap<Integer, BigInteger> sumBy = Iterate.sumByBigInteger(Interval.oneTo(10), each -> (each.intValue() % 2), each -> BigInteger.valueOf(each.longValue())));

Since:

8.1

select

public static <T,R extends Collection<T>> Collector<T,?,R> select(Predicate<? super T> predicate,
                                                                  Supplier<R> supplier)

Returns all elements of the stream that return true when evaluating the predicate. This method is also commonly called filter. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableList<Integer> evens1 = Interval.oneTo(10).stream().collect(Collectors2.select(e -> e % 2 == 0, Lists.mutable::empty));
MutableList<Integer> evens2 = Interval.oneTo(10).reduceInPlace(Collectors2.select(e -> e % 2 == 0, Lists.mutable::empty));

Equivalent to using @RichIterable.select(Predicate, Collection)

MutableList<Integer> evens = Interval.oneTo(10).select(e -> e % 2 == 0, Lists.mutable.empty());

selectWith

public static <T,P,R extends Collection<T>> Collector<T,?,R> selectWith(Predicate2<? super T,? super P> predicate,
                                                                        P parameter,
                                                                        Supplier<R> supplier)

Returns all elements of the stream that return true when evaluating the predicate with the parameter. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableList<Integer> evens1 = Interval.oneTo(10).stream().collect(Collectors2.selectWith((e, p) -> e % p == 0, 2, Lists.mutable::empty));
MutableList<Integer> evens2 = Interval.oneTo(10).reduceInPlace(Collectors2.selectWith((e, p) -> e % p == 0, 2, Lists.mutable::empty));

Equivalent to using @RichIterable.selectWith(Predicate2, Object, Collection)

MutableList<Integer> evens = Interval.oneTo(10).selectWith((e, p) -> e % p == 0, 2, Lists.mutable.empty());

reject

public static <T,R extends Collection<T>> Collector<T,?,R> reject(Predicate<? super T> predicate,
                                                                  Supplier<R> supplier)

Returns all elements of the stream that return false when evaluating the predicate. This method is also commonly called filterNot. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableList<Integer> odds1 = Interval.oneTo(10).stream().collect(Collectors2.reject(e -> e % 2 == 0, Lists.mutable::empty));
MutableList<Integer> odds2 = Interval.oneTo(10).reduceInPlace(Collectors2.reject(e -> e % 2 == 0, Lists.mutable::empty));

Equivalent to using @RichIterable.reject(Predicate, Collection)

MutableList<Integer> odds = Interval.oneTo(10).reject(e -> e % 2 == 0, Lists.mutable.empty());

rejectWith

public static <T,P,R extends Collection<T>> Collector<T,?,R> rejectWith(Predicate2<? super T,? super P> predicate,
                                                                        P parameter,
                                                                        Supplier<R> supplier)

Returns all elements of the stream that return false when evaluating the predicate with the parameter. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableList<Integer> odds1 = Interval.oneTo(10).stream().collect(Collectors2.rejectWith((e, p) -> e % p == 0, 2, Lists.mutable::empty));
MutableList<Integer> odds2 = Interval.oneTo(10).reduceInPlace(Collectors2.rejectWith((e, p) -> e % p == 0, 2, Lists.mutable::empty));

Equivalent to using @RichIterable.rejectWith(Predicate2, Object, Collection)

MutableList<Integer> odds = Interval.oneTo(10).rejectWith((e, p) -> e % p == 0, 2, Lists.mutable.empty());

partition

public static <T,R extends PartitionMutableCollection<T>> Collector<T,?,R> partition(Predicate<? super T> predicate,
                                                                                     Supplier<R> supplier)

Returns all elements of the stream split into a PartitionMutableCollection after evaluating the predicate. The new PartitionMutableCollection is created as the result of evaluating the provided Supplier.

Examples:

PartitionMutableList<Integer> evensAndOdds1 = Interval.oneTo(10).stream().collect(Collectors2.partition(e -> e % 2 == 0, PartitionFastList::new));
PartitionMutableList<Integer> evensAndOdds2 = Interval.oneTo(10).reduceInPlace(Collectors2.partition(e -> e % 2 == 0, PartitionFastList::new));

Equivalent to using @RichIterable.partition(Predicate)

PartitionMutableList<Integer> evensAndOdds = Interval.oneTo(10).partition(e -> e % 2 == 0);

partitionWith

public static <T,P,R extends PartitionMutableCollection<T>> Collector<T,?,R> partitionWith(Predicate2<? super T,? super P> predicate,
                                                                                           P parameter,
                                                                                           Supplier<R> supplier)

Returns all elements of the stream split into a PartitionMutableCollection after evaluating the predicate. The new PartitionMutableCollection is created as the result of evaluating the provided Supplier.

Examples:

PartitionMutableList<Integer> evensAndOdds1 = Interval.oneTo(10).stream().collect(Collectors2.partitionWith((e, p) -> e % p == 0, 2, PartitionFastList::new));
PartitionMutableList<Integer> evensAndOdds2 = Interval.oneTo(10).reduceInPlace(Collectors2.partitionWith((e, p) -> e % p == 0, 2, PartitionFastList::new));

Equivalent to using @RichIterable.partitionWith(Predicate2, Object)

PartitionMutableList<Integer> evensAndOdds = Interval.oneTo(10).partitionWith((e, p) -> e % p == 0, 2);

collect

public static <T,V,R extends Collection<V>> Collector<T,?,R> collect(Function<? super T,? extends V> function,
                                                                     Supplier<R> supplier)

Returns a new collection with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableList<String> collect1 = Interval.oneTo(10).stream().collect(Collectors2.collect(Object::toString, Lists.mutable::empty));
MutableList<String> collect2 = Interval.oneTo(10).reduceInPlace(Collectors2.collect(Object::toString, Lists.mutable::empty));

Equivalent to using @RichIterable.collect(Function, Collection)

MutableList<String> collect = Interval.oneTo(10).collect(Object::toString, Lists.mutable.empty());

flatCollect

public static <T,V,R extends Collection<V>> Collector<T,?,R> flatCollect(Function<? super T,? extends Iterable<V>> function,
                                                                         Supplier<R> supplier)

The method flatCollect is a special case of collect(Function, Supplier). With collect, when the Function returns a collection, the result is a collection of collections. flatCollect outputs a single "flattened" collection instead. This method is commonly called flatMap.

Example:

 List<MutableList<String>> lists =
     Lists.mutable.with(
         Lists.mutable.with("a", "b"),
         Lists.mutable.with("c", "d"),
         Lists.mutable.with("e"));

 MutableList<String> flattened =
     lists.stream().collect(Collectors2.flatCollect(l -> l, Lists.mutable::empty));

 Assert.assertEquals(Lists.mutable.with("a", "b", "c", "d", "e"), flattened);

collectWith

public static <T,P,V,R extends Collection<V>> Collector<T,?,R> collectWith(Function2<? super T,? super P,? extends V> function,
                                                                           P parameter,
                                                                           Supplier<R> supplier)

Returns a new collection with the results of applying the specified function on each element of the source collection with the specified parameter. This method is also commonly called transform or map. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableList<Integer> collect1 = Interval.oneTo(10).stream().collect(Collectors2.collectWith(Integer::sum, Integer.valueOf(10), Lists.mutable::empty));
MutableList<Integer> collect2 = Interval.oneTo(10).reduceInPlace(Collectors2.collectWith(Integer::sum, Integer.valueOf(10), Lists.mutable::empty));

Equivalent to using @RichIterable.collectWith(Function2, Object, Collection)

MutableList<Integer> collect = Interval.oneTo(10).collectWith(Integer::sum, Integer.valueOf(10), Lists.mutable.empty());

collectBoolean

public static <T,R extends MutableBooleanCollection> Collector<T,?,R> collectBoolean(BooleanFunction<? super T> function,
                                                                                     Supplier<R> supplier)

Returns a new MutableBooleanCollection with the results of applying the specified BooleanFunction on each element of the source. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableBooleanList collect1 = Interval.oneTo(10).stream().collect(Collectors2.collectBoolean(each -> each % 2 == 0, BooleanLists.mutable::empty));
MutableBooleanList collect2 = Interval.oneTo(10).reduceInPlace(Collectors2.collectBoolean(each -> each % 2 == 0, BooleanLists.mutable::empty));

Equivalent to using @RichIterable.collectBoolean(BooleanFunction, MutableBooleanCollection)

MutableBooleanList collect = Interval.oneTo(10).collectBoolean(each -> each % 2 == 0, BooleanLists.mutable.empty());

collectByte

public static <T,R extends MutableByteCollection> Collector<T,?,R> collectByte(ByteFunction<? super T> function,
                                                                               Supplier<R> supplier)

Returns a new MutableByteCollection with the results of applying the specified ByteFunction on each element of the source. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableByteList collect1 = Interval.oneTo(10).stream().collect(Collectors2.collectByte(each -> (byte) (each % Byte.MAX_VALUE), ByteLists.mutable::empty));
MutableByteList collect2 = Interval.oneTo(10).reduceInPlace(Collectors2.collectByte(each -> (byte) (each % Byte.MAX_VALUE), ByteLists.mutable::empty));

Equivalent to using @RichIterable.collectByte(ByteFunction, MutableByteCollection)

MutableByteList collect = Interval.oneTo(10).collectByte(each -> (byte) (each % Byte.MAX_VALUE), ByteLists.mutable.empty());

collectChar

public static <T,R extends MutableCharCollection> Collector<T,?,R> collectChar(CharFunction<? super T> function,
                                                                               Supplier<R> supplier)

Returns a new MutableCharCollection with the results of applying the specified CharFunction on each element of the source. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableCharList collect1 = Interval.oneTo(10).stream().collect(Collectors2.collectChar(each -> (char) (each % Character.MAX_VALUE), CharLists.mutable::empty));
MutableCharList collect2 = Interval.oneTo(10).reduceInPlace(Collectors2.collectChar(each -> (char) (each % Character.MAX_VALUE), CharLists.mutable::empty));

Equivalent to using @RichIterable.collectChar(CharFunction, MutableCharCollection)

MutableCharList collect = Interval.oneTo(10).collectChar(each -> (char) (each % Character.MAX_VALUE), CharLists.mutable.empty());

collectShort

public static <T,R extends MutableShortCollection> Collector<T,?,R> collectShort(ShortFunction<? super T> function,
                                                                                 Supplier<R> supplier)

Returns a new MutableShortCollection with the results of applying the specified ShortFunction on each element of the source. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableShortList collect1 = Interval.oneTo(10).stream().collect(Collectors2.collectShort(each -> (short) (each % Short.MAX_VALUE), ShortLists.mutable::empty));
MutableShortList collect2 = Interval.oneTo(10).reduceInPlace(Collectors2.collectShort(each -> (short) (each % Short.MAX_VALUE), ShortLists.mutable::empty));

Equivalent to using @RichIterable.collectShort(ShortFunction, MutableShortCollection)

MutableShortList collect = Interval.oneTo(10).collectShort(each -> (short) (each % Short.MAX_VALUE), ShortLists.mutable.empty());

collectInt

public static <T,R extends MutableIntCollection> Collector<T,?,R> collectInt(IntFunction<? super T> function,
                                                                             Supplier<R> supplier)

Returns a new MutableIntCollection with the results of applying the specified IntFunction on each element of the source. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableIntList collect1 = Interval.oneTo(10).stream().collect(Collectors2.collectInt(each -> each, IntLists.mutable::empty));
MutableIntList collect2 = Interval.oneTo(10).reduceInPlace(Collectors2.collectInt(each -> each, IntLists.mutable::empty));

Equivalent to using @RichIterable.collectInt(IntFunction, MutableIntCollection)

MutableIntList collect = Interval.oneTo(10).collectInt(each -> each, IntLists.mutable.empty());

collectFloat

public static <T,R extends MutableFloatCollection> Collector<T,?,R> collectFloat(FloatFunction<? super T> function,
                                                                                 Supplier<R> supplier)

Returns a new MutableFloatCollection with the results of applying the specified FloatFunction on each element of the source. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableFloatList collect1 = Interval.oneTo(10).stream().collect(Collectors2.collectFloat(each -> (float) each, FloatLists.mutable::empty));
MutableFloatList collect2 = Interval.oneTo(10).reduceInPlace(Collectors2.collectFloat(each -> (float) each, FloatLists.mutable::empty));

Equivalent to using @RichIterable.collectFloat(FloatFunction, MutableFloatCollection)

MutableFloatList collect = Interval.oneTo(10).collectFloat(each -> (float) each, FloatLists.mutable.empty());

collectLong

public static <T,R extends MutableLongCollection> Collector<T,?,R> collectLong(LongFunction<? super T> function,
                                                                               Supplier<R> supplier)

Returns a new MutableLongCollection with the results of applying the specified LongFunction on each element of the source. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableLongList collect1 = Interval.oneTo(10).stream().collect(Collectors2.collectLong(each -> (long) each, LongLists.mutable::empty));
MutableLongList collect2 = Interval.oneTo(10).reduceInPlace(Collectors2.collectLong(each -> (long) each, LongLists.mutable::empty));

Equivalent to using @RichIterable.collectLong(LongFunction, MutableLongCollection)

MutableLongList collect = Interval.oneTo(10).collectLong(each -> (long) each, LongLists.mutable.empty());

collectDouble

public static <T,R extends MutableDoubleCollection> Collector<T,?,R> collectDouble(DoubleFunction<? super T> function,
                                                                                   Supplier<R> supplier)

Returns a new MutableDoubleCollection with the results of applying the specified DoubleFunction on each element of the source. The new collection is created as the result of evaluating the provided Supplier.

Examples:

MutableDoubleList collect1 = Interval.oneTo(10).stream().collect(Collectors2.collectDouble(each -> (double) each, DoubleLists.mutable::empty));
MutableDoubleList collect2 = Interval.oneTo(10).reduceInPlace(Collectors2.collectDouble(each -> (double) each, DoubleLists.mutable::empty));

Equivalent to using @RichIterable.collectDouble(DoubleFunction, MutableDoubleCollection)

MutableDoubleList collect = Interval.oneTo(10).collectDouble(each -> (double) each, DoubleLists.mutable.empty());

summarizing

public static <T> Collector<T,?,SummaryStatistics<T>> summarizing(ImmutableList<IntFunction<? super T>> intFunctions,
                                                                  ImmutableList<LongFunction<? super T>> longFunctions,
                                                                  ImmutableList<DoubleFunction<? super T>> doubleFunctions)

Returns a SummaryStatistics with results for int, long and double functions calculated for each element in the Stream or Collection this Collector is applied to.

Since:

8.1

summarizingBigDecimal

public static <T> Collector<T,?,BigDecimalSummaryStatistics> summarizingBigDecimal(Function<? super T,BigDecimal> function)

Returns a BigDecimalSummaryStatistics applying the specified function to each element of the stream or collection.

Since:

8.1

summarizingBigInteger

public static <T> Collector<T,?,BigIntegerSummaryStatistics> summarizingBigInteger(Function<? super T,BigInteger> function)

Returns a BigIntegerSummaryStatistics applying the specified function to each element of the stream or collection.

Since:

8.1

summingBigDecimal

public static <T> Collector<T,?,BigDecimal> summingBigDecimal(Function<? super T,BigDecimal> function)

Returns a BigDecimal sum applying the specified function to each element of the stream or collection.

Since:

8.1

summingBigInteger

public static <T> Collector<T,?,BigInteger> summingBigInteger(Function<? super T,BigInteger> function)

Returns a BigInteger sum applying the specified function to each element of the stream or collection.

Since:

8.1