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

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static <T,K,R extends MutableMapIterable<K,T>> Collector<T,?,R>`	`aggregateBy(Function<? super T,? extends K> groupBy, Function0<? extends T> zeroValueFactory, Function2<? super T,? super T,? extends T> aggregator, Supplier<R> supplier)`	Groups the elements using the `groupBy` function and all the elements that map to the same key are aggregated together using the `aggregator` function.
`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,K> Collector<T,?,MutableBag<K>>`	`countBy(Function<? super T,? extends K> function)`	Returns the counts of all the values returned by applying the specified function to each item of the Stream.
`static <T,K> Collector<T,?,MutableBag<K>>`	`countByEach(Function<? super T,? extends Iterable<K>> function)`	Same as `countBy(Function)`, except the result of applying the specified function will return a collection of keys for each value.
`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,K,R extends MutableMultimap<K,T>> Collector<T,?,R>`	`groupByEach(Function<? super T,? extends Iterable<K>> groupBy, Supplier<R> supplier)`	Same as `groupBy(Function, Supplier)`, except the result of evaluating groupBy function will return a collection of keys for each value.
`static <T,K,R extends MutableMapIterable<K,T>> Collector<T,?,R>`	`groupByUniqueKey(Function<? super T,? extends K> groupBy, Supplier<R> supplier)`	Same as `groupBy(Function, Supplier)`, except the result of evaluating groupBy function should return a unique key, or else an exception is thrown.
`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,?,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,V extends Comparable<? super V>> Collector<T,?,ImmutableSortedBag<T>>`	`toImmutableSortedBagBy(Function<? super T,? extends V> function)`	Returns the elements as a ImmutableSortedBag using the specified function.
`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,V extends Comparable<? super V>> Collector<T,?,ImmutableList<T>>`	`toImmutableSortedListBy(Function<? super T,? extends V> function)`	Returns the elements as a ImmutableList that has been sorted using the specified comparator.
`static <T,K,V> Collector<T,?,ImmutableSortedMap<K,V>>`	`toImmutableSortedMap(Comparator<? super K> comparator, Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)`	Returns the elements as a ImmutableSortedMap that has been sorted using the specified comparator after applying the keyFunction and valueFunction to each element.
`static <T,K,V> Collector<T,?,ImmutableSortedMap<K,V>>`	`toImmutableSortedMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)`	Returns the elements as a ImmutableSortedMap that has been sorted after applying the keyFunction and valueFunction to each element.
`static <T,KK extends Comparable<? super KK>,K,V> Collector<T,?,ImmutableSortedMap<K,V>>`	`toImmutableSortedMapBy(Function<? super K,KK> sortBy, Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)`	Returns the elements as a ImmutableSortedMap 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,V extends Comparable<? super V>> Collector<T,?,ImmutableSortedSet<T>>`	`toImmutableSortedSetBy(Function<? super T,? extends V> function)`	Returns the elements as a ImmutableSortedSet using the specified function to compare each element.
`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,K,V> Collector<T,?,MutableSortedMap<K,V>>`	`toSortedMap(Comparator<? super K> comparator, Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)`	Returns the elements as a MutableSortedMap that has been sorted using the specified comparator after applying the keyFunction and valueFunction to each element.
`static <T,K,V> Collector<T,?,MutableSortedMap<K,V>>`	`toSortedMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)`	Returns the elements as a MutableSortedMap that has been sorted after applying the keyFunction and valueFunction to each element.
`static <T,KK extends Comparable<? super KK>,K,V> Collector<T,?,MutableSortedMap<K,V>>`	`toSortedMapBy(Function<? super K,KK> sortBy, Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)`	Returns the elements as a MutableSortedMap that has been sorted using the specified comparator after applying the keyFunction and valueFunction to each element.
`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();
  - toImmutableSortedSetBy
```
public static <T,V extends Comparable<? super V>> Collector<T,?,ImmutableSortedSet<T>> toImmutableSortedSetBy(Function<? super T,? extends V> function)
```
    Returns the elements as a ImmutableSortedSet using the specified function to compare each element.
    
    Examples:
    ImmutableSortedSet<Integer> set1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSortedSetBy(Object::toString));
    ImmutableSortedSet<Integer> set2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSortedSetBy(Object::toString));
    Equivalent to using @RichIterable.toImmutableSortedSetBy(Function).
    ImmutableSortedSet<Integer> set = Interval.oneTo(5).toImmutableSortedSetBy(Object::toString);
  - 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();
  - toImmutableSortedListBy
```
public static <T,V extends Comparable<? super V>> Collector<T,?,ImmutableList<T>> toImmutableSortedListBy(Function<? super T,? extends V> function)
```
    Returns the elements as a ImmutableList that has been sorted using the specified comparator.
    
    Examples:
    ImmutableList<Integer> list1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSortedListBy(Object::toString));
    ImmutableList<Integer> list2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSortedListBy(Object::toString));
    Equivalent to using @RichIterable.toImmutableSortedListBy(Function)}
    ImmutableList<Integer> list = Interval.oneTo(5).toImmutableSortedListBy(Object::toString);
  - 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();
  - toImmutableSortedBagBy
```
public static <T,V extends Comparable<? super V>> Collector<T,?,ImmutableSortedBag<T>> toImmutableSortedBagBy(Function<? super T,? extends V> function)
```
    Returns the elements as a ImmutableSortedBag using the specified function.
    
    Examples:
    ImmutableSortedBag<Integer> bag1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSortedBagBy(Object::toString));
    ImmutableSortedBag<Integer> bag2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSortedBagBy(Object::toString));
    Equivalent to using @RichIterable.toImmutableSortedBagBy(Function)}
    ImmutableSortedBag<Integer> bag = Interval.oneTo(5).toImmutableSortedBagBy(Object::toString);
  - 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);
  - toSortedMap
```
public static <T,K,V> Collector<T,?,MutableSortedMap<K,V>> toSortedMap(Function<? super T,? extends K> keyFunction,
                                                                                                     Function<? super T,? extends V> valueFunction)
```
    Returns the elements as a MutableSortedMap that has been sorted after applying the keyFunction and valueFunction to each element.
    
    Examples:
    MutableSortedMap<Integer, String> map1 = Interval.oneTo(5).stream().collect(Collectors2.toSortedMap(Functions.identity(), Object::toString));
    MutableSortedMap<Integer, String> map2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSortedMap(Functions.identity(), Object::toString));
    Equivalent to using @RichIterable.toSortedMap(Function, Function)}
    MutableSortedMap<Integer, String> map = Interval.oneTo(5).toSortedMap(Functions.identity(), Object::toString);
    
    Since:
    
    11.0
  - toSortedMap
```
public static <T,K,V> Collector<T,?,MutableSortedMap<K,V>> toSortedMap(Comparator<? super K> comparator,
                                                                                                     Function<? super T,? extends K> keyFunction,
                                                                                                     Function<? super T,? extends V> valueFunction)
```
    Returns the elements as a MutableSortedMap that has been sorted using the specified comparator after applying the keyFunction and valueFunction to each element.
    
    Examples:
    MutableSortedMap<Integer, String> map1 = Interval.oneTo(5).stream().collect(Collectors2.toSortedMap(Comparators.naturalOrder(), Functions.identity(), Object::toString));
    MutableSortedMap<Integer, String> map2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSortedMap(Comparators.naturalOrder(), Functions.identity(), Object::toString));
    Equivalent to using @RichIterable.toSortedMap(Comparator, Function, Function) (Comparator)}}
    MutableSortedMap<Integer, String> map = Interval.oneTo(5).toSortedMap(Comparators.naturalOrder(), Functions.identity(), Object::toString);
    
    Since:
    
    11.0
  - toSortedMapBy
```
public static <T,KK extends Comparable<? super KK>,K,V> Collector<T,?,MutableSortedMap<K,V>> toSortedMapBy(Function<? super K,KK> sortBy,
                                                                                                                                               Function<? super T,? extends K> keyFunction,
                                                                                                                                               Function<? super T,? extends V> valueFunction)
```
    Returns the elements as a MutableSortedMap that has been sorted using the specified comparator after applying the keyFunction and valueFunction to each element.
    
    Examples:
    MutableSortedMap<Integer, String> map1 = Interval.oneTo(5).stream().collect(Collectors2.toSortedMap(Object::toString, Functions.identity(), Object::toString));
    MutableSortedMap<Integer, String> map2 = Interval.oneTo(5).reduceInPlace(Collectors2.toSortedMap(Object::toString, Functions.identity(), Object::toString));
    Equivalent to using @RichIterable.toSortedMapBy(Function, Function, Function)
    MutableSortedMap<Integer, String> map = Interval.oneTo(5).toSortedMapBy(Object::toString, Functions.identity(), Object::toString);
    
    Since:
    
    11.0
  - 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();
  - toImmutableSortedMap
```
public static <T,K,V> Collector<T,?,ImmutableSortedMap<K,V>> toImmutableSortedMap(Function<? super T,? extends K> keyFunction,
                                                                                                                Function<? super T,? extends V> valueFunction)
```
    Returns the elements as a ImmutableSortedMap that has been sorted after applying the keyFunction and valueFunction to each element.
    
    Examples:
    ImmutableSortedMap<Integer, String> map1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSortedMap(Functions.identity(), Object::toString));
    ImmutableSortedMap<Integer, String> map2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSortedMap(Functions.identity(), Object::toString));
    Equivalent to using @RichIterable.toSortedMap(Function, Function)} followed by: @MutableMapIterable.toImmutable().
    ImmutableSortedMap<Integer, String> map = Interval.oneTo(5).toSortedMap(Functions.identity(), Object::toString).toImmutable();
    
    Since:
    
    11.0
  - toImmutableSortedMap
```
public static <T,K,V> Collector<T,?,ImmutableSortedMap<K,V>> toImmutableSortedMap(Comparator<? super K> comparator,
                                                                                                                Function<? super T,? extends K> keyFunction,
                                                                                                                Function<? super T,? extends V> valueFunction)
```
    Returns the elements as a ImmutableSortedMap that has been sorted using the specified comparator after applying the keyFunction and valueFunction to each element.
    
    Examples:
    ImmutableSortedMap<Integer, String> map1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSortedMap(Comparators.naturalOrder(), Functions.identity(), Object::toString));
    ImmutableSortedMap<Integer, String> map2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSortedMap(Comparators.naturalOrder(), Functions.identity(), Object::toString));
    Equivalent to using @RichIterable.toSortedMap(Comparator, Function, Function)} followed by: @MutableMapIterable.toImmutable().
    ImmutableSortedMap<Integer, String> map = Interval.oneTo(5).toSortedMap(Comparators.naturalOrder(), Functions.identity(), Object::toString).toImmutable();
    
    Since:
    
    11.0
  - toImmutableSortedMapBy
```
public static <T,KK extends Comparable<? super KK>,K,V> Collector<T,?,ImmutableSortedMap<K,V>> toImmutableSortedMapBy(Function<? super K,KK> sortBy,
                                                                                                                                                          Function<? super T,? extends K> keyFunction,
                                                                                                                                                          Function<? super T,? extends V> valueFunction)
```
    Returns the elements as a ImmutableSortedMap that has been sorted using the specified comparator.
    
    Examples:
    ImmutableSortedMap<Integer, String> map1 = Interval.oneTo(5).stream().collect(Collectors2.toImmutableSortedMap(Object::toString, Functions.identity(), Object::toString));
    ImmutableSortedMap<Integer, String> map2 = Interval.oneTo(5).reduceInPlace(Collectors2.toImmutableSortedMap(Object::toString, Functions.identity(), Object::toString));
    Equivalent to using @RichIterable.toSortedMapBy(Function, Function, Function) followed by: @MutableMapIterable.toImmutable().
    ImmutableSortedMap<Integer, String> map = Interval.oneTo(5).toSortedMap(Object::toString, Functions.identity(), Object::toString).toImmutable();
    
    Since:
    
    11.0
  - countBy
```
public static <T,K> Collector<T,?,MutableBag<K>> countBy(Function<? super T,? extends K> function)
```
    Returns the counts of all the values returned by applying the specified function to each item of the Stream.
    
    Since:
    
    9.1
  - countByEach
```
public static <T,K> Collector<T,?,MutableBag<K>> countByEach(Function<? super T,? extends Iterable<K>> function)
```
    Same as countBy(Function), except the result of applying the specified function will return a collection of keys for each value.
    
    Since:
    
    9.2
  - 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());
  - groupByEach
```
public static <T,K,R extends MutableMultimap<K,T>> Collector<T,?,R> groupByEach(Function<? super T,? extends Iterable<K>> groupBy,
                                                                                                              Supplier<R> supplier)
```
    Same as groupBy(Function, Supplier), except the result of evaluating groupBy function will return a collection of keys for each value.
    
    Equivalent to using @RichIterable.groupByEach(Function, MutableMultimap)
  - groupByUniqueKey
```
public static <T,K,R extends MutableMapIterable<K,T>> Collector<T,?,R> groupByUniqueKey(Function<? super T,? extends K> groupBy,
                                                                                                                      Supplier<R> supplier)
```
    Same as groupBy(Function, Supplier), except the result of evaluating groupBy function should return a unique key, or else an exception is thrown.
    
    Equivalent to using RichIterable.groupByUniqueKey(Function, MutableMapIterable)
  - 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));
  - aggregateBy
```
public static <T,K,R extends MutableMapIterable<K,T>> Collector<T,?,R> aggregateBy(Function<? super T,? extends K> groupBy,
                                                                                                                 Function0<? extends T> zeroValueFactory,
                                                                                                                 Function2<? super T,? super T,? extends T> aggregator,
                                                                                                                 Supplier<R> supplier)
```
    Groups the elements using the groupBy function and all the elements that map to the same key are aggregated together using the aggregator function. The second parameter, the zeroValueFactory function, creates the initial value in each aggregation. Aggregate results are allowed to be immutable as they will be replaced in the map.
  - 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());
  - 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

Class Collectors2

Method Summary

Methods inherited from class java.lang.Object

Method Detail

makeString

makeString

makeString

toList

toImmutableList

toSet

toImmutableSet

toSortedSet

toImmutableSortedSet

toSortedSet

toSortedSetBy

toImmutableSortedSet

toImmutableSortedSetBy

toBag

toImmutableBag

toSortedList

toImmutableSortedList

toSortedList

toSortedListBy

toImmutableSortedList

toImmutableSortedListBy

toSortedBag

toImmutableSortedBag

toSortedBag

toSortedBagBy

toImmutableSortedBag

toImmutableSortedBagBy

toStack

toImmutableStack

toBiMap

toImmutableBiMap

toMap

toSortedMap

toSortedMap

toSortedMapBy

toImmutableMap

toImmutableSortedMap

toImmutableSortedMap

toImmutableSortedMapBy

countBy

countByEach

groupBy

groupByEach

groupByUniqueKey

groupByAndCollect

aggregateBy

toListMultimap

toListMultimap

toSetMultimap

toSetMultimap

toBagMultimap

toBagMultimap

toImmutableListMultimap

toImmutableListMultimap

toImmutableSetMultimap

toImmutableSetMultimap

toImmutableBagMultimap

toImmutableBagMultimap

chunk

zip

zipWithIndex

sumByInt

sumByLong

sumByFloat

sumByDouble

sumByBigDecimal

sumByBigInteger

select

selectWith

reject

rejectWith

partition

partitionWith

collect

flatCollect

collectWith