com.gs.collections.api

Interface RichIterable<T>

All Superinterfaces:

InternalIterable<T>, java.lang.Iterable<T>

All Known Subinterfaces:

Bag<T>, BiMap<K,V>, ByteObjectMap<V>, CharObjectMap<V>, ConcurrentMutableMap<K,V>, DoubleObjectMap<V>, FixedSizeCollection<T>, FixedSizeList<T>, FixedSizeMap<K,V>, FixedSizeSet<T>, FloatObjectMap<V>, ImmutableBag<T>, ImmutableBiMap<K,V>, ImmutableByteObjectMap<V>, ImmutableCharObjectMap<V>, ImmutableCollection<T>, ImmutableDoubleObjectMap<V>, ImmutableFloatObjectMap<V>, ImmutableIntObjectMap<V>, ImmutableList<T>, ImmutableLongObjectMap<V>, ImmutableMap<K,V>, ImmutableSet<T>, ImmutableShortObjectMap<V>, ImmutableSortedBag<T>, ImmutableSortedMap<K,V>, ImmutableSortedSet<T>, ImmutableStack<T>, IntObjectMap<V>, LazyIterable<T>, ListIterable<T>, LongObjectMap<V>, MapIterable<K,V>, MutableBag<T>, MutableBiMap<K,V>, MutableByteObjectMap<V>, MutableCharObjectMap<V>, MutableCollection<T>, MutableDoubleObjectMap<V>, MutableFloatObjectMap<V>, MutableIntObjectMap<V>, MutableList<T>, MutableLongObjectMap<V>, MutableMap<K,V>, MutableSet<T>, MutableShortObjectMap<V>, MutableSortedBag<T>, MutableSortedMap<K,V>, MutableSortedSet<T>, MutableStack<T>, ReversibleIterable<T>, SetIterable<T>, ShortObjectMap<V>, SortedBag<T>, SortedIterable<T>, SortedMapIterable<K,V>, SortedSetIterable<T>, StackIterable<T>, UnsortedBag<T>, UnsortedMapIterable<K,V>, UnsortedSetIterable<T>

public interface RichIterable<T>
extends InternalIterable<T>

RichIterable is an interface which extends the InternalIterable interface with several internal iterator methods, from the Smalltalk Collection protocol. These include select, reject, detect, collect, injectInto, anySatisfy, allSatisfy. The API also includes converter methods to convert a RichIterable to a List (toList), to a sorted List (toSortedList), to a Set (toSet), and to a Map (toMap).

Since:

1.0

Method Summary

Methods

Modifier and Type	Method and Description
<K,V> MapIterable<K,V>	aggregateBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator) Applies an aggregate function over the iterable grouping results into a map based on the specific groupBy function.
<K,V> MapIterable<K,V>	aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator) Applies an aggregate procedure over the iterable grouping results into a Map based on the specific groupBy function.
boolean	allSatisfy(Predicate<? super T> predicate) Returns true if the predicate evaluates to true for every element of the iterable or if the iterable is empty.
<P> boolean	allSatisfyWith(Predicate2<? super T,? super P> predicate, P parameter) Returns true if the predicate evaluates to true for every element of the collection, or returns false.
boolean	anySatisfy(Predicate<? super T> predicate) Returns true if the predicate evaluates to true for any element of the iterable.
<P> boolean	anySatisfyWith(Predicate2<? super T,? super P> predicate, P parameter) Returns true if the predicate evaluates to true for any element of the collection, or return false.
void	appendString(java.lang.Appendable appendable) Prints a string representation of this collection onto the given Appendable.
void	appendString(java.lang.Appendable appendable, java.lang.String separator) Prints a string representation of this collection onto the given Appendable.
void	appendString(java.lang.Appendable appendable, java.lang.String start, java.lang.String separator, java.lang.String end) Prints a string representation of this collection onto the given Appendable.
LazyIterable<T>	asLazy() Returns a lazy (deferred) iterable, most likely implemented by calling LazyIterate.adapt(this).
RichIterable<RichIterable<T>>	chunk(int size) Partitions elements in fixed size chunks.
<V> RichIterable<V>	collect(Function<? super T,? extends V> function) Returns a new collection with the results of applying the specified function on each element of the source collection.
<V,R extends java.util.Collection<V>> R	collect(Function<? super T,? extends V> function, R target) Same as collect(Function), except that the results are gathered into the specified target collection.
BooleanIterable	collectBoolean(BooleanFunction<? super T> booleanFunction) Returns a new primitive boolean iterable with the results of applying the specified function on each element of the source collection.
<R extends MutableBooleanCollection> R	collectBoolean(BooleanFunction<? super T> booleanFunction, R target) Same as collectBoolean(BooleanFunction), except that the results are gathered into the specified target collection.
ByteIterable	collectByte(ByteFunction<? super T> byteFunction) Returns a new primitive byte iterable with the results of applying the specified function on each element of the source collection.
<R extends MutableByteCollection> R	collectByte(ByteFunction<? super T> byteFunction, R target) Same as collectByte(ByteFunction), except that the results are gathered into the specified target collection.
CharIterable	collectChar(CharFunction<? super T> charFunction) Returns a new primitive char iterable with the results of applying the specified function on each element of the source collection.
<R extends MutableCharCollection> R	collectChar(CharFunction<? super T> charFunction, R target) Same as collectChar(CharFunction), except that the results are gathered into the specified target collection.
DoubleIterable	collectDouble(DoubleFunction<? super T> doubleFunction) Returns a new primitive double iterable with the results of applying the specified function on each element of the source collection.
<R extends MutableDoubleCollection> R	collectDouble(DoubleFunction<? super T> doubleFunction, R target) Same as collectDouble(DoubleFunction), except that the results are gathered into the specified target collection.
FloatIterable	collectFloat(FloatFunction<? super T> floatFunction) Returns a new primitive float iterable with the results of applying the specified function on each element of the source collection.
<R extends MutableFloatCollection> R	collectFloat(FloatFunction<? super T> floatFunction, R target) Same as collectFloat(FloatFunction), except that the results are gathered into the specified target collection.
<V> RichIterable<V>	collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function) Returns a new collection with the results of applying the specified function on each element of the source collection, but only for those elements which return true upon evaluation of the predicate.
<V,R extends java.util.Collection<V>> R	collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function, R target) Same as the collectIf method with two parameters but uses the specified target collection for the results.
IntIterable	collectInt(IntFunction<? super T> intFunction) Returns a new primitive int iterable with the results of applying the specified function on each element of the source collection.
<R extends MutableIntCollection> R	collectInt(IntFunction<? super T> intFunction, R target) Same as collectInt(IntFunction), except that the results are gathered into the specified target collection.
LongIterable	collectLong(LongFunction<? super T> longFunction) Returns a new primitive long iterable with the results of applying the specified function on each element of the source collection.
<R extends MutableLongCollection> R	collectLong(LongFunction<? super T> longFunction, R target) Same as collectLong(LongFunction), except that the results are gathered into the specified target collection.
ShortIterable	collectShort(ShortFunction<? super T> shortFunction) Returns a new primitive short iterable with the results of applying the specified function on each element of the source collection.
<R extends MutableShortCollection> R	collectShort(ShortFunction<? super T> shortFunction, R target) Same as collectShort(ShortFunction), except that the results are gathered into the specified target collection.
<P,V> RichIterable<V>	collectWith(Function2<? super T,? super P,? extends V> function, P parameter) Same as collect with a Function2 and specified parameter which is passed to the block
<P,V,R extends java.util.Collection<V>> R	collectWith(Function2<? super T,? super P,? extends V> function, P parameter, R targetCollection) Same as collectWith but with a targetCollection parameter to gather the results.
boolean	contains(java.lang.Object object) Returns true if the iterable has an element which responds true to element.equals(object).
boolean	containsAll(java.util.Collection<?> source) Returns true if all elements in source are contained in this collection.
boolean	containsAllArguments(java.lang.Object... elements) Returns true if all elements in the specified var arg array are contained in this collection.
boolean	containsAllIterable(java.lang.Iterable<?> source) Returns true if all elements in source are contained in this collection.
int	count(Predicate<? super T> predicate) Return the total number of elements that answer true to the specified predicate.
<P> int	countWith(Predicate2<? super T,? super P> predicate, P parameter) Returns the total number of elements that evaluate to true for the specified predicate.
T	detect(Predicate<? super T> predicate) Returns the first element of the iterable for which the predicate evaluates to true or null in the case where no element returns true.
T	detectIfNone(Predicate<? super T> predicate, Function0<? extends T> function) Returns the first element of the iterable for which the predicate evaluates to true.
<P> T	detectWith(Predicate2<? super T,? super P> predicate, P parameter) Returns the first element that evaluates to true for the specified predicate2 and parameter, or null if none evaluate to true.
<P> T	detectWithIfNone(Predicate2<? super T,? super P> predicate, P parameter, Function0<? extends T> function) Returns the first element of the iterable that evaluates to true for the specified predicate2 and parameter, or returns the value of evaluating the specified function.
<V> RichIterable<V>	flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function) flatCollect is a special case of collect(Function).
<V,R extends java.util.Collection<V>> R	flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function, R target) Same as flatCollect, only the results are collected into the target collection.
T	getFirst() Returns the first element of an iterable.
T	getLast() Returns the last element of an iterable.
<V> Multimap<V,T>	groupBy(Function<? super T,? extends V> function) For each element of the iterable, the function is evaluated and the results of these evaluations are collected into a new multimap, where the transformed value is the key and the original values are added to the same (or similar) species of collection as the source iterable.
<V,R extends MutableMultimap<V,T>> R	groupBy(Function<? super T,? extends V> function, R target) Same as groupBy(Function), except that the results are gathered into the specified target multimap.
<V> Multimap<V,T>	groupByEach(Function<? super T,? extends java.lang.Iterable<V>> function) Similar to groupBy(Function), except the result of evaluating function will return a collection of keys for each value.
<V,R extends MutableMultimap<V,T>> R	groupByEach(Function<? super T,? extends java.lang.Iterable<V>> function, R target) Same as groupByEach(Function), except that the results are gathered into the specified target multimap.
<V> MapIterable<V,T>	groupByUniqueKey(Function<? super T,? extends V> function) For each element of the iterable, the function is evaluated and he results of these evaluations are collected into a new map, where the transformed value is the key.
double	injectInto(double injectedValue, DoubleObjectToDoubleFunction<? super T> function) Returns the final double result of evaluating function using each element of the iterable and the previous evaluation result as the parameters.
float	injectInto(float injectedValue, FloatObjectToFloatFunction<? super T> function) Returns the final float result of evaluating function using each element of the iterable and the previous evaluation result as the parameters.
int	injectInto(int injectedValue, IntObjectToIntFunction<? super T> function) Returns the final int result of evaluating function using each element of the iterable and the previous evaluation result as the parameters.
<IV> IV	injectInto(IV injectedValue, Function2<? super IV,? super T,? extends IV> function) Returns the final result of evaluating function using each element of the iterable and the previous evaluation result as the parameters.
long	injectInto(long injectedValue, LongObjectToLongFunction<? super T> function) Returns the final long result of evaluating function using each element of the iterable and the previous evaluation result as the parameters.
boolean	isEmpty() Returns true if this iterable has zero items.
java.lang.String	makeString() Returns a string representation of this collection by delegating to makeString(String) and defaulting the separator parameter to the characters ", " (comma and space).
java.lang.String	makeString(java.lang.String separator) Returns a string representation of this collection by delegating to makeString(String, String, String) and defaulting the start and end parameters to "" (the empty String).
java.lang.String	makeString(java.lang.String start, java.lang.String separator, java.lang.String end) Returns a string representation of this collection.
T	max() Returns the maximum element out of this container based on the natural order.
T	max(java.util.Comparator<? super T> comparator) Returns the maximum element out of this container based on the comparator.
<V extends java.lang.Comparable<? super V>> T	maxBy(Function<? super T,? extends V> function) Returns the maximum elements out of this container based on the natural order of the attribute returned by Function.
T	min() Returns the minimum element out of this container based on the natural order.
T	min(java.util.Comparator<? super T> comparator) Returns the minimum element out of this container based on the comparator.
<V extends java.lang.Comparable<? super V>> T	minBy(Function<? super T,? extends V> function) Returns the minimum elements out of this container based on the natural order of the attribute returned by Function.
boolean	noneSatisfy(Predicate<? super T> predicate) Returns true if the predicate evaluates to false for every element of the iterable or if the iterable is empty.
<P> boolean	noneSatisfyWith(Predicate2<? super T,? super P> predicate, P parameter) Returns true if the predicate evaluates to false for every element of the collection, or return false.
boolean	notEmpty() The English equivalent of !this.isEmpty()
PartitionIterable<T>	partition(Predicate<? super T> predicate) Filters a collection into a PartitionedIterable based on the evaluation of the predicate.
<P> PartitionIterable<T>	partitionWith(Predicate2<? super T,? super P> predicate, P parameter) Filters a collection into a PartitionIterable based on the evaluation of the predicate.
RichIterable<T>	reject(Predicate<? super T> predicate) Returns all elements of the source collection that return false when evaluating of the predicate.
<R extends java.util.Collection<T>> R	reject(Predicate<? super T> predicate, R target) Same as the reject method with one parameter but uses the specified target collection for the results.
<P> RichIterable<T>	rejectWith(Predicate2<? super T,? super P> predicate, P parameter) Similar to reject(Predicate), except with an evaluation parameter for the second generic argument in Predicate2.
<P,R extends java.util.Collection<T>> R	rejectWith(Predicate2<? super T,? super P> predicate, P parameter, R targetCollection) Similar to reject(Predicate, Collection), except with an evaluation parameter for the second generic argument in Predicate2.
RichIterable<T>	select(Predicate<? super T> predicate) Returns all elements of the source collection that return true when evaluating the predicate.
<R extends java.util.Collection<T>> R	select(Predicate<? super T> predicate, R target) Same as the select method with one parameter but uses the specified target collection for the results.
<S> RichIterable<S>	selectInstancesOf(java.lang.Class<S> clazz) Returns all elements of the source collection that are instances of the Class clazz.
<P> RichIterable<T>	selectWith(Predicate2<? super T,? super P> predicate, P parameter) Similar to select(Predicate), except with an evaluation parameter for the second generic argument in Predicate2.
<P,R extends java.util.Collection<T>> R	selectWith(Predicate2<? super T,? super P> predicate, P parameter, R targetCollection) Similar to select(Predicate, Collection), except with an evaluation parameter for the second generic argument in Predicate2.
int	size() Returns the number of items in this iterable.
double	sumOfDouble(DoubleFunction<? super T> function) Returns the final double result of evaluating function for each element of the iterable and adding the results together.
double	sumOfFloat(FloatFunction<? super T> function) Returns the final double result of evaluating function for each element of the iterable and adding the results together.
long	sumOfInt(IntFunction<? super T> function) Returns the final long result of evaluating function for each element of the iterable and adding the results together.
long	sumOfLong(LongFunction<? super T> function) Returns the final long result of evaluating function for each element of the iterable and adding the results together.
java.lang.Object[]	toArray() Converts this iterable to an array.
<T> T[]	toArray(T[] target) Converts this iterable to an array using the specified target array, assuming the target array is as long or longer than the iterable.
MutableBag<T>	toBag() Converts the collection to the default MutableBag implementation.
MutableList<T>	toList() Converts the collection to a MutableList implementation.
<NK,NV> MutableMap<NK,NV>	toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction) Converts the collection to a MutableMap implementation using the specified key and value functions.
MutableSet<T>	toSet() Converts the collection to a MutableSet implementation.
MutableList<T>	toSortedList() Converts the collection to a MutableList implementation and sorts it using the natural order of the elements.
MutableList<T>	toSortedList(java.util.Comparator<? super T> comparator) Converts the collection to a MutableList implementation and sorts it using the specified comparator.
<V extends java.lang.Comparable<? super V>> MutableList<T>	toSortedListBy(Function<? super T,? extends V> function) Converts the collection to a MutableList implementation and sorts it based on the natural order of the attribute returned by function.
<NK,NV> MutableSortedMap<NK,NV>	toSortedMap(java.util.Comparator<? super NK> comparator, Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction) Converts the collection to a MutableSortedMap implementation using the specified key and value functions sorted by the given comparator.
<NK,NV> MutableSortedMap<NK,NV>	toSortedMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction) Converts the collection to a MutableSortedMap implementation using the specified key and value functions sorted by the key elements' natural ordering.
MutableSortedSet<T>	toSortedSet() Converts the collection to a MutableSortedSet implementation and sorts it using the natural order of the elements.
MutableSortedSet<T>	toSortedSet(java.util.Comparator<? super T> comparator) Converts the collection to a MutableSortedSet implementation and sorts it using the specified comparator.
<V extends java.lang.Comparable<? super V>> MutableSortedSet<T>	toSortedSetBy(Function<? super T,? extends V> function) Converts the collection to a MutableSortedSet implementation and sorts it based on the natural order of the attribute returned by function.
java.lang.String	toString() Returns a string representation of this RichIterable.
<S> RichIterable<Pair<T,S>>	zip(java.lang.Iterable<S> that) Returns a RichIterable formed from this RichIterable and another RichIterable by combining corresponding elements in pairs.
<S,R extends java.util.Collection<Pair<T,S>>> R	zip(java.lang.Iterable<S> that, R target) Same as zip(Iterable) but uses target for output.
RichIterable<Pair<T,java.lang.Integer>>	zipWithIndex() Zips this RichIterable with its indices.
<R extends java.util.Collection<Pair<T,java.lang.Integer>>> R	zipWithIndex(R target) Same as zipWithIndex() but uses target for output.

Methods inherited from interface com.gs.collections.api.InternalIterable

forEach, forEachWith, forEachWithIndex

Methods inherited from interface java.lang.Iterable

iterator

Method Detail

size

int size()

Returns the number of items in this iterable.

Since:

1.0

isEmpty

boolean isEmpty()

Returns true if this iterable has zero items.

Since:

1.0

notEmpty

boolean notEmpty()

The English equivalent of !this.isEmpty()

Since:

1.0

getFirst

T getFirst()

Returns the first element of an iterable. In the case of a List it is the element at the first index. In the case of any other Collection, it is the first element that would be returned during an iteration. If the iterable is empty, null is returned. If null is a valid element of the container, then a developer would need to check to see if the iterable is empty to validate that a null result was not due to the container being empty.

The order of Sets are not guaranteed (except for TreeSets and other Ordered Set implementations), so if you use this method, the first element could be any element from the Set.

Since:

1.0

getLast

T getLast()

Returns the last element of an iterable. In the case of a List it is the element at the last index. In the case of any other Collection, it is the last element that would be returned during an iteration. If the iterable is empty, null is returned. If null is a valid element of the container, then a developer would need to check to see if the iterable is empty to validate that a null result was not due to the container being empty.

The order of Sets are not guaranteed (except for TreeSets and other Ordered Set implementations), so if you use this method, the last element could be any element from the Set.

Since:

1.0

contains

boolean contains(java.lang.Object object)

Returns true if the iterable has an element which responds true to element.equals(object).

Since:

1.0

containsAllIterable

boolean containsAllIterable(java.lang.Iterable<?> source)

Returns true if all elements in source are contained in this collection.

Since:

1.0

containsAll

boolean containsAll(java.util.Collection<?> source)

Returns true if all elements in source are contained in this collection.

Since:

1.0

See Also:

Collection.containsAll(Collection)

containsAllArguments

boolean containsAllArguments(java.lang.Object... elements)

Returns true if all elements in the specified var arg array are contained in this collection.

Since:

1.0

select

RichIterable<T> select(Predicate<? super T> predicate)

Returns all elements of the source collection that return true when evaluating the predicate. This method is also commonly called filter.

e.g.
 return people.select(new Predicate<Person>()
 {
     public boolean accept(Person person)
     {
         return person.getAddress().getCity().equals("Metuchen");
     }
 });
 

Since:

1.0

select

<R extends java.util.Collection<T>> R select(Predicate<? super T> predicate,
                                           R target)

Same as the select method with one parameter but uses the specified target collection for the results.

e.g.
 return people.select(new Predicate<Person>()
 {
     public boolean accept(Person person)
     {
         return person.person.getLastName().equals("Smith");
     }
 }, Lists.mutable.of());
 

e.g.
 return collection.select(Predicates.attributeEqual("lastName", "Smith"), new ArrayList());
 

Parameters:

predicate - a Predicate to use as the select criteria

target - the Collection to append to for all elements in this RichIterable that meet select criteria predicate

Returns:

target, which contains appended elements as a result of the select criteria

Since:

1.0

See Also:

select(Predicate)

selectWith

<P> RichIterable<T> selectWith(Predicate2<? super T,? super P> predicate,
                             P parameter)

Similar to select(Predicate), except with an evaluation parameter for the second generic argument in Predicate2.

Parameters:

predicate - a Predicate2 to use as the select criteria

parameter - a parameter to pass in for evaluation of the second argument P in predicate

Since:

5.0

See Also:

select(Predicate)

selectWith

<P,R extends java.util.Collection<T>> R selectWith(Predicate2<? super T,? super P> predicate,
                                                 P parameter,
                                                 R targetCollection)

Similar to select(Predicate, Collection), except with an evaluation parameter for the second generic argument in Predicate2.

Parameters:

predicate - a Predicate2 to use as the select criteria

parameter - a parameter to pass in for evaluation of the second argument P in predicate

targetCollection - the Collection to append to for all elements in this RichIterable that meet select criteria predicate

Returns:

targetCollection, which contains appended elements as a result of the select criteria

Since:

1.0

See Also:

select(Predicate), select(Predicate, Collection)

reject

RichIterable<T> reject(Predicate<? super T> predicate)

Returns all elements of the source collection that return false when evaluating of the predicate. This method is also sometimes called filterNot and is the equivalent of calling iterable.select(Predicates.not(predicate)).

e.g.
 return people.reject(new Predicate<Person>()
 {
     public boolean accept(Person person)
     {
         return person.person.getLastName().equals("Smith");
     }
 });
 

e.g.
 return people.reject(Predicates.attributeEqual("lastName", "Smith"));
 

Parameters:

predicate - a Predicate to use as the reject criteria

Returns:

a RichIterable that contains elements that cause Predicate.accept(Object) method to evaluate to false

Since:

1.0

rejectWith

<P> RichIterable<T> rejectWith(Predicate2<? super T,? super P> predicate,
                             P parameter)

Similar to reject(Predicate), except with an evaluation parameter for the second generic argument in Predicate2.

Parameters:

predicate - a Predicate2 to use as the select criteria

parameter - a parameter to pass in for evaluation of the second argument P in predicate

Since:

5.0

See Also:

select(Predicate)

reject

<R extends java.util.Collection<T>> R reject(Predicate<? super T> predicate,
                                           R target)

Same as the reject method with one parameter but uses the specified target collection for the results.

e.g.
 return people.reject(new Predicate<Person>()
 {
     public boolean accept(Person person)
     {
         return person.person.getLastName().equals("Smith");
     }
 }, Lists.mutable.of());
 

Parameters:

predicate - a Predicate to use as the reject criteria

target - the Collection to append to for all elements in this RichIterable that cause Predicate#accept(Object) method to evaluate to false

Returns:

target, which contains appended elements as a result of the reject criteria

Since:

1.0

rejectWith

<P,R extends java.util.Collection<T>> R rejectWith(Predicate2<? super T,? super P> predicate,
                                                 P parameter,
                                                 R targetCollection)

Similar to reject(Predicate, Collection), except with an evaluation parameter for the second generic argument in Predicate2.

E.g. return a Collection of Person elements where the person has a height greater than 100cm

 return people.reject(new Predicate2<Person, Integer>()
 {
     public boolean accept(Person p, Integer i)
     {
         return p.getHeightInCm() < i.intValue();
     }
 }, Integer.valueOf(100), FastList.newList());
 

Parameters:

predicate - a Predicate2 to use as the reject criteria

parameter - a parameter to pass in for evaluation of the second argument P in predicate

targetCollection - the Collection to append to for all elements in this RichIterable that cause Predicate#accept(Object) method to evaluate to false

Returns:

targetCollection, which contains appended elements as a result of the reject criteria

Since:

1.0

See Also:

reject(Predicate), reject(Predicate, Collection)

partition

PartitionIterable<T> partition(Predicate<? super T> predicate)

Filters a collection into a PartitionedIterable based on the evaluation of the predicate.

e.g.
 return people.partition(new Predicate<Person>()
 {
     public boolean accept(Person person)
     {
         return person.getAddress().getState().getName().equals("New York");
     }
 });
 

Since:

1.0.

partitionWith

<P> PartitionIterable<T> partitionWith(Predicate2<? super T,? super P> predicate,
                                     P parameter)

Filters a collection into a PartitionIterable based on the evaluation of the predicate.

e.g.
 return people.partitionWith(new Predicate2<Person, String>()
 {
     public boolean accept(Person person, String state)
     {
         return person.getAddress().getState().getName().equals(state);
     }
 }, "New York");
 

Since:

5.0.

selectInstancesOf

<S> RichIterable<S> selectInstancesOf(java.lang.Class<S> clazz)

Returns all elements of the source collection that are instances of the Class clazz.

Since:

2.0

collect

<V> RichIterable<V> collect(Function<? super T,? extends V> function)

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.

e.g.
 return people.collect(new Function<Person, String>()
 {
     public String valueOf(Person person)
     {
         return person.getFirstName() + " " + person.getLastName();
     }
 });
 

Since:

1.0

collectBoolean

BooleanIterable collectBoolean(BooleanFunction<? super T> booleanFunction)

Returns a new primitive boolean iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

e.g.
 return people.collectBoolean(new BooleanFunction<Person>()
 {
     public boolean booleanValueOf(Person person)
     {
         return person.hasDrivingLicense();
     }
 });
 

Since:

4.0

collectBoolean

<R extends MutableBooleanCollection> R collectBoolean(BooleanFunction<? super T> booleanFunction,
                                                    R target)

Same as collectBoolean(BooleanFunction), except that the results are gathered into the specified target collection.

e.g.
 return people.collectBoolean(new BooleanFunction<Person>()
 {
     public boolean booleanValueOf(Person person)
     {
         return person.hasDrivingLicense();
     }
 }, new BooleanArrayList());
 

Parameters:

booleanFunction - a BooleanFunction to use as the collect transformation function

target - the MutableBooleanCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

Since:

5.0

collectByte

ByteIterable collectByte(ByteFunction<? super T> byteFunction)

Returns a new primitive byte iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

e.g.
 return people.collectByte(new ByteFunction<Person>()
 {
     public byte byteValueOf(Person person)
     {
         return person.getCode();
     }
 });
 

Since:

4.0

collectByte

<R extends MutableByteCollection> R collectByte(ByteFunction<? super T> byteFunction,
                                              R target)

Same as collectByte(ByteFunction), except that the results are gathered into the specified target collection.

e.g.
 return people.collectByte(new ByteFunction<Person>()
 {
     public byte byteValueOf(Person person)
     {
         return person.getCode();
     }
 }, new ByteArrayList());
 

Parameters:

byteFunction - a ByteFunction to use as the collect transformation function

target - the MutableByteCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

Since:

5.0

collectChar

CharIterable collectChar(CharFunction<? super T> charFunction)

Returns a new primitive char iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

e.g.
 return people.collectChar(new CharFunction<Person>()
 {
     public char charValueOf(Person person)
     {
         return person.getMiddleInitial();
     }
 });
 

Since:

4.0

collectChar

<R extends MutableCharCollection> R collectChar(CharFunction<? super T> charFunction,
                                              R target)

Same as collectChar(CharFunction), except that the results are gathered into the specified target collection.

e.g.
 return people.collectChar(new CharFunction<Person>()
 {
     public char charValueOf(Person person)
     {
         return person.getMiddleInitial();
     }
 }, new CharArrayList());
 

Parameters:

charFunction - a CharFunction to use as the collect transformation function

target - the MutableCharCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

Since:

5.0

collectDouble

DoubleIterable collectDouble(DoubleFunction<? super T> doubleFunction)

Returns a new primitive double iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

e.g.
 return people.collectDouble(new DoubleFunction<Person>()
 {
     public double doubleValueOf(Person person)
     {
         return person.getMilesFromNorthPole();
     }
 });
 

Since:

4.0

collectDouble

<R extends MutableDoubleCollection> R collectDouble(DoubleFunction<? super T> doubleFunction,
                                                  R target)

Same as collectDouble(DoubleFunction), except that the results are gathered into the specified target collection.

e.g.
 return people.collectDouble(new DoubleFunction<Person>()
 {
     public double doubleValueOf(Person person)
     {
         return person.getMilesFromNorthPole();
     }
 }, new DoubleArrayList());
 

Parameters:

doubleFunction - a DoubleFunction to use as the collect transformation function

target - the MutableDoubleCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

Since:

5.0

collectFloat

FloatIterable collectFloat(FloatFunction<? super T> floatFunction)

Returns a new primitive float iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

e.g.
 return people.collectFloat(new FloatFunction<Person>()
 {
     public float floatValueOf(Person person)
     {
         return person.getHeightInInches();
     }
 });
 

Since:

4.0

collectFloat

<R extends MutableFloatCollection> R collectFloat(FloatFunction<? super T> floatFunction,
                                                R target)

Same as collectFloat(FloatFunction), except that the results are gathered into the specified target collection.

e.g.
 return people.collectFloat(new FloatFunction<Person>()
 {
     public float floatValueOf(Person person)
     {
         return person.getHeightInInches();
     }
 }, new FloatArrayList());
 

Parameters:

floatFunction - a FloatFunction to use as the collect transformation function

target - the MutableFloatCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

Since:

5.0

collectInt

IntIterable collectInt(IntFunction<? super T> intFunction)

Returns a new primitive int iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

e.g.
 return people.collectInt(new IntFunction<Person>()
 {
     public int intValueOf(Person person)
     {
         return person.getAge();
     }
 });
 

Since:

4.0

collectInt

<R extends MutableIntCollection> R collectInt(IntFunction<? super T> intFunction,
                                            R target)

Same as collectInt(IntFunction), except that the results are gathered into the specified target collection.

e.g.
 return people.collectInt(new IntFunction<Person>()
 {
     public int intValueOf(Person person)
     {
         return person.getAge();
     }
 }, new IntArrayList());
 

Parameters:

intFunction - a IntFunction to use as the collect transformation function

target - the MutableIntCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

Since:

5.0

collectLong

LongIterable collectLong(LongFunction<? super T> longFunction)

Returns a new primitive long iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

e.g.
 return people.collectLong(new LongFunction<Person>()
 {
     public long longValueOf(Person person)
     {
         return person.getGuid();
     }
 });
 

Since:

4.0

collectLong

<R extends MutableLongCollection> R collectLong(LongFunction<? super T> longFunction,
                                              R target)

Same as collectLong(LongFunction), except that the results are gathered into the specified target collection.

e.g.
 return people.collectLong(new LongFunction<Person>()
 {
     public long longValueOf(Person person)
     {
         return person.getGuid();
     }
 }, new LongArrayList());
 

Parameters:

longFunction - a LongFunction to use as the collect transformation function

target - the MutableLongCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

Since:

5.0

collectShort

ShortIterable collectShort(ShortFunction<? super T> shortFunction)

Returns a new primitive short iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

e.g.
 return people.collectShort(new ShortFunction<Person>()
 {
     public short shortValueOf(Person person)
     {
         return person.getNumberOfJunkMailItemsReceivedPerMonth();
     }
 });
 

Since:

4.0

collectShort

<R extends MutableShortCollection> R collectShort(ShortFunction<? super T> shortFunction,
                                                R target)

Same as collectShort(ShortFunction), except that the results are gathered into the specified target collection.

e.g.
 return people.collectShort(new ShortFunction<Person>()
 {
     public short shortValueOf(Person person)
     {
         return person.getNumberOfJunkMailItemsReceivedPerMonth;
     }
 }, new ShortArrayList());
 

Parameters:

shortFunction - a ShortFunction to use as the collect transformation function

target - the MutableShortCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

Since:

5.0

collect

<V,R extends java.util.Collection<V>> R collect(Function<? super T,? extends V> function,
                                              R target)

Same as collect(Function), except that the results are gathered into the specified target collection.

e.g.
 return people.collect(new Function<Person, String>()
 {
     public String valueOf(Person person)
     {
         return person.getFirstName() + " " + person.getLastName();
     }
 }, Lists.mutable.of());
 

Parameters:

function - a Function to use as the collect transformation function

target - the Collection to append to for all elements in this RichIterable that meet select criteria function

Returns:

target, which contains appended elements as a result of the collect transformation

Since:

1.0

See Also:

collect(Function)

collectWith

<P,V> RichIterable<V> collectWith(Function2<? super T,? super P,? extends V> function,
                                P parameter)

Same as collect with a Function2 and specified parameter which is passed to the block

e.g.
 Function2 addParameterFunction =
 new Function2()
 {
      public Integer value(final Integer each, final Integer parameter)
      {
          return each + parameter;
      }
 };
 FastList.newListWith(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1));
 

Parameters:

function - A Function2 to use as the collect transformation function

parameter - A parameter to pass in for evaluation of the second argument P in function

Returns:

A new RichIterable that contains the transformed elements returned by Function2.value(Object, Object)

Since:

5.0

See Also:

collect(Function)

collectWith

<P,V,R extends java.util.Collection<V>> R collectWith(Function2<? super T,? super P,? extends V> function,
                                                    P parameter,
                                                    R targetCollection)

Same as collectWith but with a targetCollection parameter to gather the results.

e.g.
 Function2 addParameterFunction =
 new Function2()
 {
      public Integer value(final Integer each, final Integer parameter)
      {
          return each + parameter;
      }
 };
 FastList.newListWith(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1), UnifiedSet.newSet());
 

Parameters:

function - a Function2 to use as the collect transformation function

parameter - a parameter to pass in for evaluation of the second argument P in function

targetCollection - the Collection to append to for all elements in this RichIterable that meet select criteria function

Returns:

targetCollection, which contains appended elements as a result of the collect transformation

Since:

1.0

collectIf

<V> RichIterable<V> collectIf(Predicate<? super T> predicate,
                            Function<? super T,? extends V> function)

Returns a new collection with the results of applying the specified function on each element of the source collection, but only for those elements which return true upon evaluation of the predicate. This is the the optimized equivalent of calling iterable.select(predicate).collect(function).

e.g.
 Lists.mutable.of().with(1, 2, 3).collectIf(Predicates.notNull(), Functions.getToString())
 

Since:

1.0

collectIf

<V,R extends java.util.Collection<V>> R collectIf(Predicate<? super T> predicate,
                                                Function<? super T,? extends V> function,
                                                R target)

Same as the collectIf method with two parameters but uses the specified target collection for the results.

Parameters:

predicate - a Predicate to use as the select criteria

function - a Function to use as the collect transformation function

target - the Collection to append to for all elements in this RichIterable that meet the collect criteria predicate

Returns:

targetCollection, which contains appended elements as a result of the collect criteria and transformation

Since:

1.0

See Also:

collectIf(Predicate, Function)

flatCollect

<V> RichIterable<V> flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function)

flatCollect is a special case of collect(Function). 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.

Consider the following example where we have a Person class, and each Person has a list of Address objects. Take the following Function:

 Function<Person, List<Address>> addressFunction = new Function<Person, List<Address>>() {
     public List<Address> valueOf(Person person) {
         return person.getAddresses();
     }
 };
 MutableList<Person> people = ...;
 

Using collect returns a collection of collections of addresses.

 MutableList<List<Address>> addresses = people.collect(addressFunction);
 

Using flatCollect returns a single flattened list of addresses.

 MutableList<Address> addresses = people.flatCollect(addressFunction);
 

Parameters:

function - The Function to apply

Returns:

a new flattened collection produced by applying the given function

Since:

1.0

flatCollect

<V,R extends java.util.Collection<V>> R flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function,
                                                  R target)

Same as flatCollect, only the results are collected into the target collection.

Parameters:

function - The Function to apply

target - The collection into which results should be added.

Returns:

target, which will contain a flattened collection of results produced by applying the given function

See Also:

flatCollect(Function)

detect

T detect(Predicate<? super T> predicate)

Returns the first element of the iterable for which the predicate evaluates to true or null in the case where no element returns true. This method is commonly called find.

e.g.
 return people.detect(new Predicate<Person>()
 {
     public boolean value(Person person)
     {
         return person.getFirstName().equals("John") && person.getLastName().equals("Smith");
     }
 });
 

Since:

1.0

detectWith

<P> T detectWith(Predicate2<? super T,? super P> predicate,
               P parameter)

Returns the first element that evaluates to true for the specified predicate2 and parameter, or null if none evaluate to true.

e.g.
 people.detectWith(new Predicate2<Person, String>()
 {
     public boolean value(Person person, String fullName)
     {
         return person.getFullName().equals(fullName);
     }
 }, "John Smith");
 

Since:

5.0

detectIfNone

T detectIfNone(Predicate<? super T> predicate,
             Function0<? extends T> function)

Returns the first element of the iterable for which the predicate evaluates to true. If no element matches the predicate, then returns the value of applying the specified function.

Since:

1.0

detectWithIfNone

<P> T detectWithIfNone(Predicate2<? super T,? super P> predicate,
                     P parameter,
                     Function0<? extends T> function)

Returns the first element of the iterable that evaluates to true for the specified predicate2 and parameter, or returns the value of evaluating the specified function.

Since:

5.0

count

int count(Predicate<? super T> predicate)

Return the total number of elements that answer true to the specified predicate.

e.g.
 return people.count(new Predicate<Person>()
 {
     public boolean value(Person person)
     {
         return person.getAddress().getState().getName().equals("New York");
     }
 });
 

Since:

1.0

countWith

<P> int countWith(Predicate2<? super T,? super P> predicate,
                P parameter)

Returns the total number of elements that evaluate to true for the specified predicate.

e.g.
 return lastNames.countWith(PredicatesLite.equal(), "Smith");
 

anySatisfy

boolean anySatisfy(Predicate<? super T> predicate)

Returns true if the predicate evaluates to true for any element of the iterable. Returns false if the iterable is empty, or if no element returned true when evaluating the predicate.

Since:

1.0

anySatisfyWith

<P> boolean anySatisfyWith(Predicate2<? super T,? super P> predicate,
                         P parameter)

Returns true if the predicate evaluates to true for any element of the collection, or return false. Returns false if the collection is empty.

Since:

5.0

allSatisfy

boolean allSatisfy(Predicate<? super T> predicate)

Returns true if the predicate evaluates to true for every element of the iterable or if the iterable is empty. Otherwise, returns false.

Since:

1.0

allSatisfyWith

<P> boolean allSatisfyWith(Predicate2<? super T,? super P> predicate,
                         P parameter)

Returns true if the predicate evaluates to true for every element of the collection, or returns false.

Since:

5.0

noneSatisfy

boolean noneSatisfy(Predicate<? super T> predicate)

Returns true if the predicate evaluates to false for every element of the iterable or if the iterable is empty. Otherwise, returns false.

Since:

3.0

noneSatisfyWith

<P> boolean noneSatisfyWith(Predicate2<? super T,? super P> predicate,
                          P parameter)

Returns true if the predicate evaluates to false for every element of the collection, or return false. Returns true if the collection is empty.

Since:

5.0

injectInto

<IV> IV injectInto(IV injectedValue,
                 Function2<? super IV,? super T,? extends IV> function)

Returns the final result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter. This method is commonly called fold or sometimes reduce.

Since:

1.0

injectInto

int injectInto(int injectedValue,
             IntObjectToIntFunction<? super T> function)

Returns the final int result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.

Since:

1.0

injectInto

long injectInto(long injectedValue,
              LongObjectToLongFunction<? super T> function)

Returns the final long result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.

Since:

1.0

injectInto

float injectInto(float injectedValue,
               FloatObjectToFloatFunction<? super T> function)

Returns the final float result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.

Since:

2.0

injectInto

double injectInto(double injectedValue,
                DoubleObjectToDoubleFunction<? super T> function)

Returns the final double result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.

Since:

1.0

toList

MutableList<T> toList()

Converts the collection to a MutableList implementation.

Since:

1.0

toSortedList

MutableList<T> toSortedList()

Converts the collection to a MutableList implementation and sorts it using the natural order of the elements.

Since:

1.0

toSortedList

MutableList<T> toSortedList(java.util.Comparator<? super T> comparator)

Converts the collection to a MutableList implementation and sorts it using the specified comparator.

Since:

1.0

toSortedListBy

<V extends java.lang.Comparable<? super V>> MutableList<T> toSortedListBy(Function<? super T,? extends V> function)

Converts the collection to a MutableList implementation and sorts it based on the natural order of the attribute returned by function.

Since:

1.0

toSet

MutableSet<T> toSet()

Converts the collection to a MutableSet implementation.

Since:

1.0

toSortedSet

MutableSortedSet<T> toSortedSet()

Converts the collection to a MutableSortedSet implementation and sorts it using the natural order of the elements.

Since:

1.0

toSortedSet

MutableSortedSet<T> toSortedSet(java.util.Comparator<? super T> comparator)

Converts the collection to a MutableSortedSet implementation and sorts it using the specified comparator.

Since:

1.0

toSortedSetBy

<V extends java.lang.Comparable<? super V>> MutableSortedSet<T> toSortedSetBy(Function<? super T,? extends V> function)

Converts the collection to a MutableSortedSet implementation and sorts it based on the natural order of the attribute returned by function.

Since:

1.0

toBag

MutableBag<T> toBag()

Converts the collection to the default MutableBag implementation.

Since:

1.0

toMap

<NK,NV> MutableMap<NK,NV> toMap(Function<? super T,? extends NK> keyFunction,
                              Function<? super T,? extends NV> valueFunction)

Converts the collection to a MutableMap implementation using the specified key and value functions.

Since:

1.0

toSortedMap

<NK,NV> MutableSortedMap<NK,NV> toSortedMap(Function<? super T,? extends NK> keyFunction,
                                          Function<? super T,? extends NV> valueFunction)

Converts the collection to a MutableSortedMap implementation using the specified key and value functions sorted by the key elements' natural ordering.

Since:

1.0

toSortedMap

<NK,NV> MutableSortedMap<NK,NV> toSortedMap(java.util.Comparator<? super NK> comparator,
                                          Function<? super T,? extends NK> keyFunction,
                                          Function<? super T,? extends NV> valueFunction)

Converts the collection to a MutableSortedMap implementation using the specified key and value functions sorted by the given comparator.

Since:

1.0

asLazy

LazyIterable<T> asLazy()

Returns a lazy (deferred) iterable, most likely implemented by calling LazyIterate.adapt(this).

Since:

1.0.

toArray

java.lang.Object[] toArray()

Converts this iterable to an array.

Since:

1.0

See Also:

Collection.toArray()

toArray

<T> T[] toArray(T[] target)

Converts this iterable to an array using the specified target array, assuming the target array is as long or longer than the iterable.

Since:

1.0

See Also:

Collection.toArray(Object[])

min

T min(java.util.Comparator<? super T> comparator)

Returns the minimum element out of this container based on the comparator.

Throws:

java.util.NoSuchElementException - if the RichIterable is empty

Since:

1.0

max

T max(java.util.Comparator<? super T> comparator)

Returns the maximum element out of this container based on the comparator.

Throws:

java.util.NoSuchElementException - if the RichIterable is empty

Since:

1.0

min

T min()

Returns the minimum element out of this container based on the natural order.

Throws:

java.lang.ClassCastException - if the elements are not Comparable

java.util.NoSuchElementException - if the RichIterable is empty

Since:

1.0

max

T max()

Returns the maximum element out of this container based on the natural order.

Throws:

java.lang.ClassCastException - if the elements are not Comparable

java.util.NoSuchElementException - if the RichIterable is empty

Since:

1.0

minBy

<V extends java.lang.Comparable<? super V>> T minBy(Function<? super T,? extends V> function)

Returns the minimum elements out of this container based on the natural order of the attribute returned by Function.

Throws:

java.util.NoSuchElementException - if the RichIterable is empty

Since:

1.0

maxBy

<V extends java.lang.Comparable<? super V>> T maxBy(Function<? super T,? extends V> function)

Returns the maximum elements out of this container based on the natural order of the attribute returned by Function.

Throws:

java.util.NoSuchElementException - if the RichIterable is empty

Since:

1.0

sumOfInt

long sumOfInt(IntFunction<? super T> function)

Returns the final long result of evaluating function for each element of the iterable and adding the results together.

Since:

2.0

sumOfFloat

double sumOfFloat(FloatFunction<? super T> function)

Returns the final double result of evaluating function for each element of the iterable and adding the results together.

Since:

2.0

sumOfLong

long sumOfLong(LongFunction<? super T> function)

Returns the final long result of evaluating function for each element of the iterable and adding the results together.

Since:

2.0

sumOfDouble

double sumOfDouble(DoubleFunction<? super T> function)

Returns the final double result of evaluating function for each element of the iterable and adding the results together.

Since:

2.0

makeString

java.lang.String makeString()

Returns a string representation of this collection by delegating to makeString(String) and defaulting the separator parameter to the characters ", " (comma and space).

Returns:

a string representation of this collection.

Since:

1.0

makeString

java.lang.String makeString(java.lang.String separator)

Returns a string representation of this collection by delegating to makeString(String, String, String) and defaulting the start and end parameters to "" (the empty String).

Returns:

a string representation of this collection.

Since:

1.0

makeString

java.lang.String makeString(java.lang.String start,
                          java.lang.String separator,
                          java.lang.String end)

Returns a string representation of this collection. The string representation consists of a list of the collection's elements in the order they are returned by its iterator, enclosed in the start and end strings. Adjacent elements are separated by the separator string. Elements are converted to strings as by String.valueOf(Object).

Returns:

a string representation of this collection.

Since:

1.0

appendString

void appendString(java.lang.Appendable appendable)

Prints a string representation of this collection onto the given Appendable. Prints the string returned by makeString().

Since:

1.0

appendString

void appendString(java.lang.Appendable appendable,
                java.lang.String separator)

Prints a string representation of this collection onto the given Appendable. Prints the string returned by makeString(String).

Since:

1.0

appendString

void appendString(java.lang.Appendable appendable,
                java.lang.String start,
                java.lang.String separator,
                java.lang.String end)

Prints a string representation of this collection onto the given Appendable. Prints the string returned by makeString(String, String, String).

Since:

1.0

groupBy

<V> Multimap<V,T> groupBy(Function<? super T,? extends V> function)

For each element of the iterable, the function is evaluated and the results of these evaluations are collected into a new multimap, where the transformed value is the key and the original values are added to the same (or similar) species of collection as the source iterable.

e.g.
 return people.groupBy(new Function<Person, String>()
 {
     public String value(Person person)
     {
         return person.getFirstName() + " " + person.getLastName();
     }
 });
 

Since:

1.0

groupBy

<V,R extends MutableMultimap<V,T>> R groupBy(Function<? super T,? extends V> function,
                                           R target)

Same as groupBy(Function), except that the results are gathered into the specified target multimap.

e.g.
 return people.groupBy(new Function<Person, String>()
 {
     public String value(Person person)
     {
         return person.getFirstName() + " " + person.getLastName();
     }
 }, new FastListMultimap<String, Person>());
 

Since:

1.0

groupByEach

<V> Multimap<V,T> groupByEach(Function<? super T,? extends java.lang.Iterable<V>> function)

Similar to groupBy(Function), except the result of evaluating function will return a collection of keys for each value.

Since:

1.0

groupByEach

<V,R extends MutableMultimap<V,T>> R groupByEach(Function<? super T,? extends java.lang.Iterable<V>> function,
                                               R target)

Same as groupByEach(Function), except that the results are gathered into the specified target multimap.

Since:

1.0

groupByUniqueKey

<V> MapIterable<V,T> groupByUniqueKey(Function<? super T,? extends V> function)

For each element of the iterable, the function is evaluated and he results of these evaluations are collected into a new map, where the transformed value is the key. The generated keys must each be unique, or else an exception is thrown.

Throws:

java.lang.IllegalStateException - if the keys returned by the function are not unique

Since:

5.0

See Also:

groupBy(Function)

toString

java.lang.String toString()

Returns a string representation of this RichIterable. The string representation consists of a list of the RichIterable's elements in the order they are returned by its iterator, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (comma and space). Elements are converted to strings as by String.valueOf(Object).

Overrides:

toString in class java.lang.Object

Returns:

a string representation of this RichIterable

Since:

1.0

zip

<S> RichIterable<Pair<T,S>> zip(java.lang.Iterable<S> that)

Returns a RichIterable formed from this RichIterable and another RichIterable by combining corresponding elements in pairs. If one of the two RichIterables is longer than the other, its remaining elements are ignored.

Type Parameters:

S - the type of the second half of the returned pairs

Parameters:

that - The RichIterable providing the second half of each result pair

Returns:

A new RichIterable containing pairs consisting of corresponding elements of this RichIterable and that. The length of the returned RichIterable is the minimum of the lengths of this RichIterable and that.

Since:

1.0

zip

<S,R extends java.util.Collection<Pair<T,S>>> R zip(java.lang.Iterable<S> that,
                                                  R target)

Same as zip(Iterable) but uses target for output.

Since:

1.0

zipWithIndex

RichIterable<Pair<T,java.lang.Integer>> zipWithIndex()

Zips this RichIterable with its indices.

Returns:

A new RichIterable containing pairs consisting of all elements of this RichIterable paired with their index. Indices start at 0.

Since:

1.0

See Also:

zip(Iterable)

zipWithIndex

<R extends java.util.Collection<Pair<T,java.lang.Integer>>> R zipWithIndex(R target)

Same as zipWithIndex() but uses target for output.

Since:

1.0

chunk

RichIterable<RichIterable<T>> chunk(int size)

Partitions elements in fixed size chunks.

Parameters:

size - the number of elements per chunk

Returns:

A RichIterable containing RichIterables of size size, except the last will be truncated if the elements don't divide evenly.

Since:

1.0

aggregateInPlaceBy

<K,V> MapIterable<K,V> aggregateInPlaceBy(Function<? super T,? extends K> groupBy,
                                        Function0<? extends V> zeroValueFactory,
                                        Procedure2<? super V,? super T> mutatingAggregator)

Applies an aggregate procedure over the iterable grouping results into a Map based on the specific groupBy function. Aggregate results are required to be mutable as they will be changed in place by the procedure. A second function specifies the initial "zero" aggregate value to work with (i.e. new AtomicInteger(0)).

Since:

3.0

aggregateBy

<K,V> MapIterable<K,V> aggregateBy(Function<? super T,? extends K> groupBy,
                                 Function0<? extends V> zeroValueFactory,
                                 Function2<? super V,? super T,? extends V> nonMutatingAggregator)

Applies an aggregate function over the iterable grouping results into a map based on the specific groupBy function. Aggregate results are allowed to be immutable as they will be replaced in place in the map. A second function specifies the initial "zero" aggregate value to work with (i.e. Integer.valueOf(0)).

Since:

3.0