相关文章推荐
有腹肌的火锅  ·  广州广佛地铁线路图·  4 月前    · 
沉着的毛衣  ·  儿童篮球训练专用-儿童篮球训练专用促销价格、 ...·  6 月前    · 
飘逸的蘑菇  ·  iPhone 无法拍照？ 这是修复它的3 ...·  1 年前    · 
正直的手电筒  ·  马云和马化腾谁更像财阀？ - 知乎·  1 年前    · 
八块腹肌的小刀  ·  走近京剧-历史溯源·  1 年前    · 
小百科  ›  Collectors2 (Eclipse Collections - 8.0.0)
string each
才高八斗的咖啡
5 月前 
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:
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,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,?, 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,?, 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.

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); 
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 Iterable s 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));

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());

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());
 
推荐文章
有腹肌的火锅  ·  广州广佛地铁线路图
4 月前
沉着的毛衣  ·  儿童篮球训练专用-儿童篮球训练专用促销价格、儿童篮球训练专用品牌
6 月前
飘逸的蘑菇  ·  iPhone 无法拍照？ 这是修复它的3 种简单方法
1 年前
正直的手电筒  ·  马云和马化腾谁更像财阀？ - 知乎
1 年前
八块腹肌的小刀  ·  走近京剧-历史溯源
1 年前
Link管理   ·   51好读   ·   Sov5搜索   ·   小百科
小百科 - 百科知识指南