public interface RichIterable<T> extends InternalIterable<T>
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(Appendable appendable)
Prints a string representation of this collection onto the given
Appendable . |
void |
appendString(Appendable appendable,
String separator)
Prints a string representation of this collection onto the given
Appendable . |
void |
appendString(Appendable appendable,
String start,
String separator,
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 Collection<V>> |
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> |
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> |
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> |
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> |
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> |
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 Collection<V>> |
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> |
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> |
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> |
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 Collection<V>> |
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(Object object)
Returns true if the iterable has an element which responds true to element.equals(object).
|
boolean |
containsAll(Collection<?> source)
Returns true if all elements in source are contained in this collection.
|
boolean |
containsAllArguments(Object... elements)
Returns true if all elements in the specified var arg array are contained in this collection.
|
boolean |
containsAllIterable(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 Iterable<V>> function)
flatCollect is a special case of collect(Function) . |
<V,R extends Collection<V>> |
flatCollect(Function<? super T,? extends 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>> |
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 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>> |
groupByEach(Function<? super T,? extends 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.
|
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). |
String |
makeString(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). |
String |
makeString(String start,
String separator,
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(Comparator<? super T> comparator)
Returns the maximum element out of this container based on the comparator.
|
<V extends Comparable<? super V>> |
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(Comparator<? super T> comparator)
Returns the minimum element out of this container based on the comparator.
|
<V extends Comparable<? super V>> |
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 Collection<T>> |
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 Collection<T>> |
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 Collection<T>> |
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(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 Collection<T>> |
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.
|
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(Comparator<? super T> comparator)
Converts the collection to a MutableList implementation and sorts it using the specified comparator.
|
<V extends Comparable<? super V>> |
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(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(Comparator<? super T> comparator)
Converts the collection to a MutableSortedSet implementation and sorts it using the specified comparator.
|
<V extends Comparable<? super V>> |
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 . |
String |
toString()
Returns a string representation of this RichIterable.
|
<S> RichIterable<Pair<T,S>> |
zip(Iterable<S> that)
Returns a
RichIterable formed from this RichIterable and another RichIterable by
combining corresponding elements in pairs. |
<S,R extends Collection<Pair<T,S>>> |
zip(Iterable<S> that,
R target)
Same as
zip(Iterable) but uses target for output. |
RichIterable<Pair<T,Integer>> |
zipWithIndex()
Zips this
RichIterable with its indices. |
<R extends Collection<Pair<T,Integer>>> |
zipWithIndex(R target)
Same as
zipWithIndex() but uses target for output. |
forEach, forEachWith, forEachWithIndex
forEach, iterator, spliterator
int size()
boolean isEmpty()
boolean notEmpty()
T getFirst()
T getLast()
boolean contains(Object object)
boolean containsAllIterable(Iterable<?> source)
boolean containsAll(Collection<?> source)
Collection.containsAll(Collection)
boolean containsAllArguments(Object... elements)
RichIterable<T> select(Predicate<? super T> predicate)
e.g. return people.select(new Predicate<Person>() { public boolean accept(Person person) { return person.getAddress().getCity().equals("Metuchen"); } });
<R extends Collection<T>> R select(Predicate<? super T> predicate, R target)
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());
predicate
- a Predicate
to use as the select criteriatarget
- the Collection to append to for all elements in this RichIterable
that meet select criteria predicate
target
, which contains appended elements as a result of the select criteriaselect(Predicate)
<P> RichIterable<T> selectWith(Predicate2<? super T,? super P> predicate, P parameter)
select(Predicate)
, except with an evaluation parameter for the second generic argument in Predicate2
.predicate
- a Predicate2
to use as the select criteriaparameter
- a parameter to pass in for evaluation of the second argument P
in predicate
select(Predicate)
<P,R extends Collection<T>> R selectWith(Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)
select(Predicate, Collection)
, except with an evaluation parameter for the second generic argument in Predicate2
.predicate
- a Predicate2
to use as the select criteriaparameter
- 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
targetCollection
, which contains appended elements as a result of the select criteriaselect(Predicate)
,
select(Predicate, Collection)
RichIterable<T> reject(Predicate<? super T> 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"));
predicate
- a Predicate
to use as the reject criteriaPredicate.accept(Object)
method to evaluate to false<P> RichIterable<T> rejectWith(Predicate2<? super T,? super P> predicate, P parameter)
reject(Predicate)
, except with an evaluation parameter for the second generic argument in Predicate2
.predicate
- a Predicate2
to use as the select criteriaparameter
- a parameter to pass in for evaluation of the second argument P
in predicate
select(Predicate)
<R extends Collection<T>> R reject(Predicate<? super T> predicate, R target)
e.g. return people.reject(new Predicate<Person>() { public boolean accept(Person person) { return person.person.getLastName().equals("Smith"); } }, Lists.mutable.of());
predicate
- a Predicate
to use as the reject criteriatarget
- the Collection to append to for all elements in this RichIterable
that cause Predicate#accept(Object)
method to evaluate to falsetarget
, which contains appended elements as a result of the reject criteria<P,R extends Collection<T>> R rejectWith(Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)
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());
predicate
- a Predicate2
to use as the reject criteriaparameter
- 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 falsetargetCollection
, which contains appended elements as a result of the reject criteriareject(Predicate)
,
reject(Predicate, Collection)
PartitionIterable<T> partition(Predicate<? super T> predicate)
e.g. return people.partition(new Predicate<Person>() { public boolean accept(Person person) { return person.getAddress().getState().getName().equals("New York"); } });
<P> PartitionIterable<T> partitionWith(Predicate2<? super T,? super P> predicate, P parameter)
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");
<S> RichIterable<S> selectInstancesOf(Class<S> clazz)
clazz
.<V> RichIterable<V> collect(Function<? super T,? extends V> function)
e.g. return people.collect(new Function<Person, String>() { public String valueOf(Person person) { return person.getFirstName() + " " + person.getLastName(); } });
BooleanIterable collectBoolean(BooleanFunction<? super T> booleanFunction)
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(); } });
<R extends MutableBooleanCollection> R collectBoolean(BooleanFunction<? super T> booleanFunction, R target)
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());
booleanFunction
- a BooleanFunction
to use as the collect transformation functiontarget
- the MutableBooleanCollection to append to for all elements in this RichIterable
target
, which contains appended elements as a result of the collect transformationByteIterable collectByte(ByteFunction<? super T> byteFunction)
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(); } });
<R extends MutableByteCollection> R collectByte(ByteFunction<? super T> byteFunction, R target)
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());
byteFunction
- a ByteFunction
to use as the collect transformation functiontarget
- the MutableByteCollection to append to for all elements in this RichIterable
target
, which contains appended elements as a result of the collect transformationCharIterable collectChar(CharFunction<? super T> charFunction)
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(); } });
<R extends MutableCharCollection> R collectChar(CharFunction<? super T> charFunction, R target)
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());
charFunction
- a CharFunction
to use as the collect transformation functiontarget
- the MutableCharCollection to append to for all elements in this RichIterable
target
, which contains appended elements as a result of the collect transformationDoubleIterable collectDouble(DoubleFunction<? super T> doubleFunction)
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(); } });
<R extends MutableDoubleCollection> R collectDouble(DoubleFunction<? super T> doubleFunction, R target)
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());
doubleFunction
- a DoubleFunction
to use as the collect transformation functiontarget
- the MutableDoubleCollection to append to for all elements in this RichIterable
target
, which contains appended elements as a result of the collect transformationFloatIterable collectFloat(FloatFunction<? super T> floatFunction)
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(); } });
<R extends MutableFloatCollection> R collectFloat(FloatFunction<? super T> floatFunction, R target)
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());
floatFunction
- a FloatFunction
to use as the collect transformation functiontarget
- the MutableFloatCollection to append to for all elements in this RichIterable
target
, which contains appended elements as a result of the collect transformationIntIterable collectInt(IntFunction<? super T> intFunction)
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(); } });
<R extends MutableIntCollection> R collectInt(IntFunction<? super T> intFunction, R target)
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());
intFunction
- a IntFunction
to use as the collect transformation functiontarget
- the MutableIntCollection to append to for all elements in this RichIterable
target
, which contains appended elements as a result of the collect transformationLongIterable collectLong(LongFunction<? super T> longFunction)
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(); } });
<R extends MutableLongCollection> R collectLong(LongFunction<? super T> longFunction, R target)
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());
longFunction
- a LongFunction
to use as the collect transformation functiontarget
- the MutableLongCollection to append to for all elements in this RichIterable
target
, which contains appended elements as a result of the collect transformationShortIterable collectShort(ShortFunction<? super T> shortFunction)
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(); } });
<R extends MutableShortCollection> R collectShort(ShortFunction<? super T> shortFunction, R target)
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());
shortFunction
- a ShortFunction
to use as the collect transformation functiontarget
- the MutableShortCollection to append to for all elements in this RichIterable
target
, which contains appended elements as a result of the collect transformation<V,R extends Collection<V>> R collect(Function<? super T,? extends V> function, R target)
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());
function
- a Function
to use as the collect transformation functiontarget
- the Collection to append to for all elements in this RichIterable
that meet select criteria function
target
, which contains appended elements as a result of the collect transformationcollect(Function)
<P,V> RichIterable<V> collectWith(Function2<? super T,? super P,? extends V> function, P parameter)
Function2
and specified parameter which is passed to the block
e.g. Function2addParameterFunction = new Function2 () { public Integer value(final Integer each, final Integer parameter) { return each + parameter; } }; FastList.newListWith(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1));
function
- A Function2
to use as the collect transformation functionparameter
- A parameter to pass in for evaluation of the second argument P
in function
RichIterable
that contains the transformed elements returned by Function2.value(Object, Object)
collect(Function)
<P,V,R extends Collection<V>> R collectWith(Function2<? super T,? super P,? extends V> function, P parameter, R targetCollection)
e.g. Function2addParameterFunction = 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());
function
- a Function2
to use as the collect transformation functionparameter
- 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
targetCollection
, which contains appended elements as a result of the collect transformation<V> RichIterable<V> collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function)
e.g. Lists.mutable.of().with(1, 2, 3).collectIf(Predicates.notNull(), Functions.getToString())
<V,R extends Collection<V>> R collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function, R target)
predicate
- a Predicate
to use as the select criteriafunction
- a Function
to use as the collect transformation functiontarget
- the Collection to append to for all elements in this RichIterable
that meet the collect criteria predicate
targetCollection
, which contains appended elements as a result of the collect criteria and transformationcollectIf(Predicate, Function)
<V> RichIterable<V> flatCollect(Function<? super T,? extends 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);
function
- The Function
to applyfunction
<V,R extends Collection<V>> R flatCollect(Function<? super T,? extends Iterable<V>> function, R target)
function
- The Function
to applytarget
- The collection into which results should be added.target
, which will contain a flattened collection of results produced by applying the given function
flatCollect(Function)
T detect(Predicate<? super T> predicate)
e.g. return people.detect(new Predicate<Person>() { public boolean value(Person person) { return person.getFirstName().equals("John") && person.getLastName().equals("Smith"); } });
<P> T detectWith(Predicate2<? super T,? super P> predicate, P parameter)
e.g. people.detectWith(new Predicate2<Person, String>() { public boolean value(Person person, String fullName) { return person.getFullName().equals(fullName); } }, "John Smith");
T detectIfNone(Predicate<? super T> predicate, Function0<? extends T> function)
<P> T detectWithIfNone(Predicate2<? super T,? super P> predicate, P parameter, Function0<? extends T> function)
int count(Predicate<? super T> predicate)
e.g. return people.count(new Predicate<Person>() { public boolean value(Person person) { return person.getAddress().getState().getName().equals("New York"); } });
<P> int countWith(Predicate2<? super T,? super P> predicate, P parameter)
e.g. return lastNames.countWith(PredicatesLite.equal(), "Smith");
boolean anySatisfy(Predicate<? super T> predicate)
<P> boolean anySatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)
boolean allSatisfy(Predicate<? super T> predicate)
<P> boolean allSatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)
boolean noneSatisfy(Predicate<? super T> predicate)
<P> boolean noneSatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)
<IV> IV injectInto(IV injectedValue, Function2<? super IV,? super T,? extends IV> function)
int injectInto(int injectedValue, IntObjectToIntFunction<? super T> function)
long injectInto(long injectedValue, LongObjectToLongFunction<? super T> function)
float injectInto(float injectedValue, FloatObjectToFloatFunction<? super T> function)
double injectInto(double injectedValue, DoubleObjectToDoubleFunction<? super T> function)
MutableList<T> toList()
MutableList<T> toSortedList()
MutableList<T> toSortedList(Comparator<? super T> comparator)
<V extends Comparable<? super V>> MutableList<T> toSortedListBy(Function<? super T,? extends V> function)
function
.MutableSet<T> toSet()
MutableSortedSet<T> toSortedSet()
MutableSortedSet<T> toSortedSet(Comparator<? super T> comparator)
<V extends Comparable<? super V>> MutableSortedSet<T> toSortedSetBy(Function<? super T,? extends V> function)
function
.MutableBag<T> toBag()
<NK,NV> MutableMap<NK,NV> toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)
<NK,NV> MutableSortedMap<NK,NV> toSortedMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)
<NK,NV> MutableSortedMap<NK,NV> toSortedMap(Comparator<? super NK> comparator, Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)
LazyIterable<T> asLazy()
Object[] toArray()
Collection.toArray()
<T> T[] toArray(T[] target)
Collection.toArray(Object[])
T min(Comparator<? super T> comparator)
NoSuchElementException
- if the RichIterable is emptyT max(Comparator<? super T> comparator)
NoSuchElementException
- if the RichIterable is emptyT min()
ClassCastException
- if the elements are not Comparable
NoSuchElementException
- if the RichIterable is emptyT max()
ClassCastException
- if the elements are not Comparable
NoSuchElementException
- if the RichIterable is empty<V extends Comparable<? super V>> T minBy(Function<? super T,? extends V> function)
NoSuchElementException
- if the RichIterable is empty<V extends Comparable<? super V>> T maxBy(Function<? super T,? extends V> function)
NoSuchElementException
- if the RichIterable is emptylong sumOfInt(IntFunction<? super T> function)
double sumOfFloat(FloatFunction<? super T> function)
long sumOfLong(LongFunction<? super T> function)
double sumOfDouble(DoubleFunction<? super T> function)
String makeString()
makeString(String)
and defaulting
the separator parameter to the characters ", " (comma and space).String makeString(String separator)
makeString(String, String, String)
and defaulting the start and end parameters to "" (the empty String).String makeString(String start, String separator, String end)
void appendString(Appendable appendable)
Appendable
. Prints the string returned
by makeString()
.void appendString(Appendable appendable, String separator)
Appendable
. Prints the string returned
by makeString(String)
.void appendString(Appendable appendable, String start, String separator, String end)
Appendable
. Prints the string returned
by makeString(String, String, String)
.<V> Multimap<V,T> groupBy(Function<? super T,? extends V> function)
e.g. return people.groupBy(new Function<Person, String>() { public String value(Person person) { return person.getFirstName() + " " + person.getLastName(); } });
<V,R extends MutableMultimap<V,T>> R groupBy(Function<? super T,? extends V> function, R target)
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>());
<V> Multimap<V,T> groupByEach(Function<? super T,? extends Iterable<V>> function)
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 Iterable<V>> function, R target)
groupByEach(Function)
, except that the results are gathered into the specified target
multimap.<V> MapIterable<V,T> groupByUniqueKey(Function<? super T,? extends V> function)
IllegalStateException
- if the keys returned by the function are not uniquegroupBy(Function)
String toString()
String.valueOf(Object)
.<S> RichIterable<Pair<T,S>> zip(Iterable<S> that)
RichIterable
formed from this RichIterable
and another RichIterable
by
combining corresponding elements in pairs. If one of the two RichIterable
s is longer than the other, its
remaining elements are ignored.S
- the type of the second half of the returned pairsthat
- The RichIterable
providing the second half of each result pairRichIterable
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.<S,R extends Collection<Pair<T,S>>> R zip(Iterable<S> that, R target)
zip(Iterable)
but uses target
for output.RichIterable<Pair<T,Integer>> zipWithIndex()
RichIterable
with its indices.RichIterable
containing pairs consisting of all elements of this RichIterable
paired with their index. Indices start at 0.zip(Iterable)
<R extends Collection<Pair<T,Integer>>> R zipWithIndex(R target)
zipWithIndex()
but uses target
for output.RichIterable<RichIterable<T>> chunk(int size)
size
- the number of elements per chunkRichIterable
containing RichIterable
s of size size
, except the last will be
truncated if the elements don't divide evenly.<K,V> MapIterable<K,V> aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
<K,V> MapIterable<K,V> aggregateBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
Copyright © 2004–2017. All rights reserved.