Interface RichIterable<T>
- All Superinterfaces:
InternalIterable<T>
,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>
,ImmutableBagIterable<T>
,ImmutableBiMap<K,V>
,ImmutableByteObjectMap<V>
,ImmutableCharObjectMap<V>
,ImmutableCollection<T>
,ImmutableDoubleObjectMap<V>
,ImmutableFloatObjectMap<V>
,ImmutableIntObjectMap<V>
,ImmutableList<T>
,ImmutableLongObjectMap<V>
,ImmutableMap<K,V>
,ImmutableMapIterable<K,V>
,ImmutableOrderedMap<K,V>
,ImmutablePrimitiveObjectMap<V>
,ImmutableSet<T>
,ImmutableSetIterable<T>
,ImmutableShortObjectMap<V>
,ImmutableSortedBag<T>
,ImmutableSortedMap<K,V>
,ImmutableSortedSet<T>
,ImmutableStack<T>
,IntObjectMap<V>
,LazyIterable<T>
,ListIterable<T>
,LongObjectMap<V>
,MapIterable<K,V>
,MultiReaderBag<T>
,MultiReaderList<T>
,MultiReaderSet<T>
,MutableBag<T>
,MutableBagIterable<T>
,MutableBiMap<K,V>
,MutableByteObjectMap<V>
,MutableCharObjectMap<V>
,MutableCollection<T>
,MutableDoubleObjectMap<V>
,MutableFloatObjectMap<V>
,MutableIntObjectMap<V>
,MutableList<T>
,MutableLongObjectMap<V>
,MutableMap<K,V>
,MutableMapIterable<K,V>
,MutableOrderedMap<K,V>
,MutablePrimitiveObjectMap<V>
,MutableSet<T>
,MutableSetIterable<T>
,MutableShortObjectMap<V>
,MutableSortedBag<T>
,MutableSortedMap<K,V>
,MutableSortedSet<T>
,MutableStack<T>
,OrderedIterable<T>
,OrderedMap<K,V>
,PrimitiveObjectMap<V>
,ReversibleIterable<T>
,SetIterable<T>
,ShortObjectMap<V>
,SortedBag<T>
,SortedIterable<T>
,SortedMapIterable<K,V>
,SortedSetIterable<T>
,StackIterable<T>
,UnsortedBag<T>
,UnsortedMapIterable<K,V>
,UnsortedSetIterable<T>
- All Known Implementing Classes:
AbstractArrayAdapter
,AbstractBag
,AbstractBiMap
,AbstractCollectionAdapter
,AbstractHashBag
,AbstractImmutableBag
,AbstractImmutableBagIterable
,AbstractImmutableBiMap
,AbstractImmutableByteObjectMap
,AbstractImmutableCharObjectMap
,AbstractImmutableCollection
,AbstractImmutableDoubleObjectMap
,AbstractImmutableFloatObjectMap
,AbstractImmutableIntObjectMap
,AbstractImmutableLongObjectMap
,AbstractImmutableMap
,AbstractImmutableSet
,AbstractImmutableShortObjectMap
,AbstractImmutableSortedMap
,AbstractLazyIterable
,AbstractListAdapter
,AbstractMapIterable
,AbstractMemoryEfficientMutableList
,AbstractMultiReaderMutableCollection
,AbstractMutableBag
,AbstractMutableBagIterable
,AbstractMutableCollection
,AbstractMutableList
,AbstractMutableMap
,AbstractMutableMapIterable
,AbstractMutableSet
,AbstractMutableSortedBag
,AbstractMutableSortedMap
,AbstractRichIterable
,AbstractSynchronizedMapIterable
,AbstractSynchronizedMutableCollection
,AbstractSynchronizedRichIterable
,AbstractUnifiedSet
,AbstractUnmodifiableMutableCollection
,ArrayAdapter
,ArrayListAdapter
,ArrayStack
,ByteObjectHashMap
,CharObjectHashMap
,ChunkBooleanIterable
,ChunkByteIterable
,ChunkCharIterable
,ChunkDoubleIterable
,ChunkFloatIterable
,ChunkIntIterable
,ChunkIterable
,ChunkLongIterable
,ChunkShortIterable
,CollectBooleanToObjectIterable
,CollectByteToObjectIterable
,CollectCharToObjectIterable
,CollectDoubleToObjectIterable
,CollectFloatToObjectIterable
,CollectIntToObjectIterable
,CollectionAdapter
,CollectIterable
,CollectLongToObjectIterable
,CollectShortToObjectIterable
,CompositeFastList
,CompositeIterable
,ConcurrentHashMap
,ConcurrentHashMapUnsafe
,ConcurrentMutableHashMap
,DistinctIterable
,DoubleObjectHashMap
,DropIterable
,DropWhileIterable
,FastList
,FlatCollectBooleanToObjectIterable
,FlatCollectByteToObjectIterable
,FlatCollectCharToObjectIterable
,FlatCollectDoubleToObjectIterable
,FlatCollectFloatToObjectIterable
,FlatCollectIntToObjectIterable
,FlatCollectIterable
,FlatCollectLongToObjectIterable
,FlatCollectShortToObjectIterable
,FloatObjectHashMap
,HashBag
,HashBagWithHashingStrategy
,HashBiMap
,ImmutableArrayBag
,ImmutableHashBag
,ImmutableTreeMap
,ImmutableUnifiedMap
,ImmutableUnifiedMapWithHashingStrategy
,Interval
,IntObjectHashMap
,LazyIterableAdapter
,ListAdapter
,LongObjectHashMap
,MapAdapter
,MultiReaderFastList
,MultiReaderHashBag
,MultiReaderUnifiedSet
,OrderedMapAdapter
,RandomAccessListAdapter
,RejectIterable
,ReverseIterable
,SelectInstancesOfIterable
,SelectIterable
,SetAdapter
,ShortObjectHashMap
,SortedMapAdapter
,SortedSetAdapter
,SynchronizedBag
,SynchronizedBiMap
,SynchronizedByteObjectMap
,SynchronizedCharObjectMap
,SynchronizedDoubleObjectMap
,SynchronizedFloatObjectMap
,SynchronizedIntObjectMap
,SynchronizedLongObjectMap
,SynchronizedMutableCollection
,SynchronizedMutableList
,SynchronizedMutableMap
,SynchronizedMutableSet
,SynchronizedRichIterable
,SynchronizedShortObjectMap
,SynchronizedSortedBag
,SynchronizedSortedMap
,SynchronizedSortedSet
,SynchronizedStack
,TakeIterable
,TakeWhileIterable
,TapIterable
,TreeBag
,TreeSortedMap
,TreeSortedSet
,UnifiedMap
,UnifiedMapWithHashingStrategy
,UnifiedSet
,UnifiedSetWithHashingStrategy
,UnmodifiableBag
,UnmodifiableBiMap
,UnmodifiableByteObjectMap
,UnmodifiableCharObjectMap
,UnmodifiableDoubleObjectMap
,UnmodifiableFloatObjectMap
,UnmodifiableIntObjectMap
,UnmodifiableLongObjectMap
,UnmodifiableMutableCollection
,UnmodifiableMutableList
,UnmodifiableMutableMap
,UnmodifiableMutableOrderedMap
,UnmodifiableMutableSet
,UnmodifiableRichIterable
,UnmodifiableShortObjectMap
,UnmodifiableSortedBag
,UnmodifiableSortedSet
,UnmodifiableStack
,UnmodifiableTreeMap
,ZipIterable
,ZipWithIndexIterable
public interface RichIterable<T> extends InternalIterable<T>
- Since:
- 1.0
-
Method Summary
Modifier and Type Method Description default <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.default <K, V, R extends MutableMapIterable<K, V>>
RaggregateBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator, R target)
Applies an aggregate function over the iterable grouping results into the target map based on the specific groupBy function.default <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.default void
appendString(Appendable appendable)
Prints a string representation of this collection onto the givenAppendable
.default void
appendString(Appendable appendable, String separator)
Prints a string representation of this collection onto the givenAppendable
.void
appendString(Appendable appendable, String start, String separator, String end)
Prints a string representation of this collection onto the givenAppendable
.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>>
Rcollect(Function<? super T,? extends V> function, R target)
Same ascollect(Function)
, except that the results are gathered into the specifiedtarget
collection.BooleanIterable
collectBoolean(BooleanFunction<? super T> booleanFunction)
Returns a new primitiveboolean
iterable with the results of applying the specified function on each element of the source collection.<R extends MutableBooleanCollection>
RcollectBoolean(BooleanFunction<? super T> booleanFunction, R target)
Same ascollectBoolean(BooleanFunction)
, except that the results are gathered into the specifiedtarget
collection.ByteIterable
collectByte(ByteFunction<? super T> byteFunction)
Returns a new primitivebyte
iterable with the results of applying the specified function on each element of the source collection.<R extends MutableByteCollection>
RcollectByte(ByteFunction<? super T> byteFunction, R target)
Same ascollectByte(ByteFunction)
, except that the results are gathered into the specifiedtarget
collection.CharIterable
collectChar(CharFunction<? super T> charFunction)
Returns a new primitivechar
iterable with the results of applying the specified function on each element of the source collection.<R extends MutableCharCollection>
RcollectChar(CharFunction<? super T> charFunction, R target)
Same ascollectChar(CharFunction)
, except that the results are gathered into the specifiedtarget
collection.DoubleIterable
collectDouble(DoubleFunction<? super T> doubleFunction)
Returns a new primitivedouble
iterable with the results of applying the specified function on each element of the source collection.<R extends MutableDoubleCollection>
RcollectDouble(DoubleFunction<? super T> doubleFunction, R target)
Same ascollectDouble(DoubleFunction)
, except that the results are gathered into the specifiedtarget
collection.FloatIterable
collectFloat(FloatFunction<? super T> floatFunction)
Returns a new primitivefloat
iterable with the results of applying the specified function on each element of the source collection.<R extends MutableFloatCollection>
RcollectFloat(FloatFunction<? super T> floatFunction, R target)
Same ascollectFloat(FloatFunction)
, except that the results are gathered into the specifiedtarget
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>>
RcollectIf(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 primitiveint
iterable with the results of applying the specified function on each element of the source collection.<R extends MutableIntCollection>
RcollectInt(IntFunction<? super T> intFunction, R target)
Same ascollectInt(IntFunction)
, except that the results are gathered into the specifiedtarget
collection.LongIterable
collectLong(LongFunction<? super T> longFunction)
Returns a new primitivelong
iterable with the results of applying the specified function on each element of the source collection.<R extends MutableLongCollection>
RcollectLong(LongFunction<? super T> longFunction, R target)
Same ascollectLong(LongFunction)
, except that the results are gathered into the specifiedtarget
collection.ShortIterable
collectShort(ShortFunction<? super T> shortFunction)
Returns a new primitiveshort
iterable with the results of applying the specified function on each element of the source collection.<R extends MutableShortCollection>
RcollectShort(ShortFunction<? super T> shortFunction, R target)
Same ascollectShort(ShortFunction)
, except that the results are gathered into the specifiedtarget
collection.<P, V> RichIterable<V>
collectWith(Function2<? super T,? super P,? extends V> function, P parameter)
Same ascollect(Function)
with aFunction2
and specified parameter which is passed to the block.<P, V, R extends Collection<V>>
RcollectWith(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.default <V> boolean
containsBy(Function<? super T,? extends V> function, V value)
Returns true if the iterable has an element which responds true to element.equals(value) after applying the specified function to the element.int
count(Predicate<? super T> predicate)
Return the total number of elements that answer true to the specified predicate.default <V> Bag<V>
countBy(Function<? super T,? extends V> function)
This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.default <V, R extends MutableBagIterable<V>>
RcountBy(Function<? super T,? extends V> function, R target)
This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.default <V> Bag<V>
countByEach(Function<? super T,? extends Iterable<V>> function)
This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.default <V, R extends MutableBagIterable<V>>
RcountByEach(Function<? super T,? extends Iterable<V>> function, R target)
This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.default <V, P> Bag<V>
countByWith(Function2<? super T,? super P,? extends V> function, P parameter)
This method will count the number of occurrences of each value calculated by applying the function to each element of the collection with the specified parameter as the second argument.default <V, P, R extends MutableBagIterable<V>>
RcountByWith(Function2<? super T,? super P,? extends V> function, P parameter, R target)
This method will count the number of occurrences of each value calculated by applying the function to each element of the collection with the specified parameter as the second argument.<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.default T
detectIfNone(Predicate<? super T> predicate, Function0<? extends T> function)
Returns the first element of the iterable for which the predicate evaluates to true.Optional<T>
detectOptional(Predicate<? super T> predicate)
Returns the first element of the iterable for which the predicate evaluates to true as an Optional.<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.<P> Optional<T>
detectWithOptional(Predicate2<? super T,? super P> predicate, P parameter)
Returns the first element that evaluates to true for the specified predicate2 and parameter as an Optional.void
each(Procedure<? super T> procedure)
The procedure is executed for each element in the iterable.<V> RichIterable<V>
flatCollect(Function<? super T,? extends Iterable<V>> function)
flatCollect
is a special case ofcollect(Function)
.<V, R extends Collection<V>>
RflatCollect(Function<? super T,? extends Iterable<V>> function, R target)
Same as flatCollect, only the results are collected into the target collection.default <R extends MutableBooleanCollection>
RflatCollectBoolean(Function<? super T,? extends BooleanIterable> function, R target)
Same as flatCollect, only the results are collected into the target collection.default <R extends MutableByteCollection>
RflatCollectByte(Function<? super T,? extends ByteIterable> function, R target)
Same as flatCollect, only the results are collected into the target collection.default <R extends MutableCharCollection>
RflatCollectChar(Function<? super T,? extends CharIterable> function, R target)
Same as flatCollect, only the results are collected into the target collection.default <R extends MutableDoubleCollection>
RflatCollectDouble(Function<? super T,? extends DoubleIterable> function, R target)
Same as flatCollect, only the results are collected into the target collection.default <R extends MutableFloatCollection>
RflatCollectFloat(Function<? super T,? extends FloatIterable> function, R target)
Same as flatCollect, only the results are collected into the target collection.default <R extends MutableIntCollection>
RflatCollectInt(Function<? super T,? extends IntIterable> function, R target)
Same as flatCollect, only the results are collected into the target collection.default <R extends MutableLongCollection>
RflatCollectLong(Function<? super T,? extends LongIterable> function, R target)
Same as flatCollect, only the results are collected into the target collection.default <R extends MutableShortCollection>
RflatCollectShort(Function<? super T,? extends ShortIterable> function, R target)
Same as flatCollect, only the results are collected into the target collection.default <P, V> RichIterable<V>
flatCollectWith(Function2<? super T,? super P,? extends Iterable<V>> function, P parameter)
default <P, V, R extends Collection<V>>
RflatCollectWith(Function2<? super T,? super P,? extends Iterable<V>> function, P parameter, R target)
default void
forEach(Procedure<? super T> procedure)
The procedure is executed for each element in the iterable.default T
getAny()
Returns any element of an iterable.T
getFirst()
Deprecated.in 6.0.T
getLast()
Deprecated.in 6.0.default T
getOnly()
Returns the element if the iterable has exactly one element.<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>>
RgroupBy(Function<? super T,? extends V> function, R target)
Same asgroupBy(Function)
, except that the results are gathered into the specifiedtarget
multimap.default <K, V, R extends MutableMultimap<K, V>>
RgroupByAndCollect(Function<? super T,? extends K> groupByFunction, Function<? super T,? extends V> collectFunction, R target)
Applies a groupBy function over the iterable, followed by a collect function.<V> Multimap<V,T>
groupByEach(Function<? super T,? extends Iterable<V>> function)
Similar togroupBy(Function)
, except the result of evaluating function will return a collection of keys for each value.<V, R extends MutableMultimap<V, T>>
RgroupByEach(Function<? super T,? extends Iterable<V>> function, R target)
Same asgroupByEach(Function)
, except that the results are gathered into the specifiedtarget
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.<V, R extends MutableMapIterable<V, T>>
RgroupByUniqueKey(Function<? super T,? extends V> function, R target)
Same asgroupByUniqueKey(Function)
, except that the results are gathered into the specifiedtarget
map.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.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.<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.<R extends Collection<T>>
Rinto(R target)
Adds all the elements in this iterable to the specific target Collection.boolean
isEmpty()
Returns true if this iterable has zero items.default String
makeString()
Returns a string representation of this collection by delegating tomakeString(String)
and defaulting the separator parameter to the characters", "
(comma and space).default String
makeString(String separator)
Returns a string representation of this collection by delegating tomakeString(String, String, String)
and defaulting the start and end parameters to""
(the empty String).default String
makeString(String start, String separator, String end)
Returns a string representation of this collection with the elements separated by the specified separator and enclosed between the start and end strings.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>>
TmaxBy(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.default <V extends Comparable<? super V>>
Optional<T>maxByOptional(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 as an Optional.default Optional<T>
maxOptional()
Returns the maximum element out of this container based on the natural order as an Optional.default Optional<T>
maxOptional(Comparator<? super T> comparator)
Returns the maximum element out of this container based on the comparator as an Optional.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>>
TminBy(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.default <V extends Comparable<? super V>>
Optional<T>minByOptional(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 as an Optional.default Optional<T>
minOptional()
Returns the minimum element out of this container based on the natural order as an Optional.default Optional<T>
minOptional(Comparator<? super T> comparator)
Returns the minimum element out of this container based on the comparator as an Optional.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.default 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.default Optional<T>
reduce(BinaryOperator<T> accumulator)
This method produces the equivalent result asStream.reduce(BinaryOperator)
.default <R> R
reduceInPlace(Supplier<R> supplier, BiConsumer<R,? super T> accumulator)
This method produces the equivalent result asStream.collect(Supplier, BiConsumer, BiConsumer)
.default <R, A> R
reduceInPlace(Collector<? super T,A,R> collector)
This method produces the equivalent result asStream.collect(Collector)
.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>>
Rreject(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 toreject(Predicate)
, except with an evaluation parameter for the second generic argument inPredicate2
.<P, R extends Collection<T>>
RrejectWith(Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)
Similar toreject(Predicate, Collection)
, except with an evaluation parameter for the second generic argument inPredicate2
.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>>
Rselect(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 Classclazz
.<P> RichIterable<T>
selectWith(Predicate2<? super T,? super P> predicate, P parameter)
Similar toselect(Predicate)
, except with an evaluation parameter for the second generic argument inPredicate2
.<P, R extends Collection<T>>
RselectWith(Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)
Similar toselect(Predicate, Collection)
, except with an evaluation parameter for the second generic argument inPredicate2
.int
size()
Returns the number of items in this iterable.<V> ObjectDoubleMap<V>
sumByDouble(Function<? super T,? extends V> groupBy, DoubleFunction<? super T> function)
Groups and sums the values using the two specified functions.<V> ObjectDoubleMap<V>
sumByFloat(Function<? super T,? extends V> groupBy, FloatFunction<? super T> function)
Groups and sums the values using the two specified functions.<V> ObjectLongMap<V>
sumByInt(Function<? super T,? extends V> groupBy, IntFunction<? super T> function)
Groups and sums the values using the two specified functions.<V> ObjectLongMap<V>
sumByLong(Function<? super T,? extends V> groupBy, LongFunction<? super T> function)
Groups and sums the values using the two specified functions.default DoubleSummaryStatistics
summarizeDouble(DoubleFunction<? super T> function)
Returns the result of summarizing the value returned from applying the DoubleFunction to each element of the iterable.default DoubleSummaryStatistics
summarizeFloat(FloatFunction<? super T> function)
Returns the result of summarizing the value returned from applying the FloatFunction to each element of the iterable.default IntSummaryStatistics
summarizeInt(IntFunction<? super T> function)
Returns the result of summarizing the value returned from applying the IntFunction to each element of the iterable.default LongSummaryStatistics
summarizeLong(LongFunction<? super T> function)
Returns the result of summarizing the value returned from applying the LongFunction to each element of the 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.RichIterable<T>
tap(Procedure<? super T> procedure)
Executes the Procedure for each element in the iterable and returnsthis
.Object[]
toArray()
Converts this iterable to an array.<E> E[]
toArray(E[] array)
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.<NK, NV> MutableBiMap<NK,NV>
toBiMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)
Converts the collection to a BiMap implementation using the specified key and value functions.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.default <NK, NV, R extends Map<NK, NV>>
RtoMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction, R target)
Same astoMap(Function, Function)
, except that the results are gathered into the specifiedtarget
map.MutableSet<T>
toSet()
Converts the collection to a MutableSet implementation.MutableSortedBag<T>
toSortedBag()
Converts the collection to a MutableSortedBag implementation and sorts it using the natural order of the elements.MutableSortedBag<T>
toSortedBag(Comparator<? super T> comparator)
Converts the collection to the MutableSortedBag implementation and sorts it using the specified comparator.default <V extends Comparable<? super V>>
MutableSortedBag<T>toSortedBagBy(Function<? super T,? extends V> function)
Converts the collection to a MutableSortedBag implementation and sorts it based on the natural order of the attribute returned byfunction
.default MutableList<T>
toSortedList()
Converts the collection to a MutableList implementation and sorts it using the natural order of the elements.default MutableList<T>
toSortedList(Comparator<? super T> comparator)
Converts the collection to a MutableList implementation and sorts it using the specified comparator.default <V extends 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 byfunction
.<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.default <KK extends Comparable<? super KK>, NK, NV>
MutableSortedMap<NK,NV>toSortedMapBy(Function<? super NK,KK> sortBy, 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 and sorts it based on the natural order of the attribute returned bysortBy
function.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.default <V extends 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 byfunction
.String
toString()
Returns a string with the elements of this iterable separated by commas with spaces and enclosed in square brackets.<S> RichIterable<Pair<T,S>>
zip(Iterable<S> that)
Deprecated.in 6.0.<S, R extends Collection<Pair<T, S>>>
Rzip(Iterable<S> that, R target)
Deprecated.in 6.0.RichIterable<Pair<T,Integer>>
zipWithIndex()
Deprecated.in 6.0.<R extends Collection<Pair<T, Integer>>>
RzipWithIndex(R target)
Deprecated.in 6.0.Methods inherited from interface org.eclipse.collections.api.InternalIterable
forEach, forEachWith, forEachWithIndex
-
Method Details
-
forEach
Description copied from interface:InternalIterable
The procedure is executed for each element in the iterable.Example using a Java 8 lambda:
people.forEach(Procedures.cast(person -> LOGGER.info(person.getName())));
Example using an anonymous inner class:
people.forEach(new Procedure<Person>() { public void value(Person person) { LOGGER.info(person.getName()); } });
NOTE: This method started to conflict withIterable.forEach(java.util.function.Consumer)
since Java 1.8. It is recommended to useeach(Procedure)
instead to avoid casting to Procedure.- Specified by:
forEach
in interfaceInternalIterable<T>
- See Also:
each(Procedure)
,Iterable.forEach(java.util.function.Consumer)
-
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
default boolean notEmpty()The English equivalent of !this.isEmpty()- Since:
- 1.0
-
getAny
Returns any element of an iterable.- Returns:
- an element of an iterable.
- Since:
- 10.0
-
getFirst
Deprecated.in 6.0. UseOrderedIterable.getFirst()
instead.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
Deprecated.in 6.0. UseOrderedIterable.getLast()
instead.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
-
getOnly
Returns the element if the iterable has exactly one element. Otherwise, throwIllegalStateException
.- Returns:
- an element of an iterable.
- Throws:
IllegalStateException
- if iterable is empty or has multiple elements.- Since:
- 8.0
-
contains
Returns true if the iterable has an element which responds true to element.equals(object).- Since:
- 1.0
-
containsBy
Returns true if the iterable has an element which responds true to element.equals(value) after applying the specified function to the element.- Since:
- 10.3
-
containsAllIterable
Returns true if all elements in source are contained in this collection.- Since:
- 1.0
-
containsAll
Returns true if all elements in source are contained in this collection.- Since:
- 1.0
- See Also:
Collection.containsAll(Collection)
-
containsAllArguments
Returns true if all elements in the specified var arg array are contained in this collection.- Since:
- 1.0
-
tap
Executes the Procedure for each element in the iterable and returnsthis
.Example using a Java 8 lambda expression:
RichIterable<Person> tapped = people.tap(person -> LOGGER.info(person.getName()));
Example using an anonymous inner class:
RichIterable<Person> tapped = people.tap(new Procedure<Person>() { public void value(Person person) { LOGGER.info(person.getName()); } });
- Since:
- 6.0
- See Also:
each(Procedure)
,forEach(Procedure)
-
each
The procedure is executed for each element in the iterable.Example using a Java 8 lambda expression:
people.each(person -> LOGGER.info(person.getName()));
Example using an anonymous inner class:
people.each(new Procedure<Person>() { public void value(Person person) { LOGGER.info(person.getName()); } });
This method is a variant ofInternalIterable.forEach(Procedure)
that has a signature conflict withIterable.forEach(java.util.function.Consumer)
.- Since:
- 6.0
- See Also:
InternalIterable.forEach(Procedure)
,Iterable.forEach(java.util.function.Consumer)
-
select
Returns all elements of the source collection that return true when evaluating the predicate. This method is also commonly called filter.Example using a Java 8 lambda expression:
RichIterable<Person> selected = people.select(person -> person.getAddress().getCity().equals("London"));
Example using an anonymous inner class:
RichIterable<Person> selected = people.select(new Predicate<Person>() { public boolean accept(Person person) { return person.getAddress().getCity().equals("London"); } });
- Since:
- 1.0
-
select
Same as the select method with one parameter but uses the specified target collection for the results.Example using a Java 8 lambda expression:
MutableList<Person> selected = people.select(person -> person.person.getLastName().equals("Smith"), Lists.mutable.empty());
Example using an anonymous inner class:
MutableList<Person> selected = people.select(new Predicate<Person>() { public boolean accept(Person person) { return person.person.getLastName().equals("Smith"); } }, Lists.mutable.empty());
- Parameters:
predicate
- aPredicate
to use as the select criteriatarget
- the Collection to append to for all elements in thisRichIterable
that meet select criteriapredicate
- Returns:
target
, which contains appended elements as a result of the select criteria- Since:
- 1.0
- See Also:
select(Predicate)
-
selectWith
Similar toselect(Predicate)
, except with an evaluation parameter for the second generic argument inPredicate2
.E.g. return a
Collection
of Person elements where the person has an age greater than or equal to 18 yearsExample using a Java 8 lambda expression:
RichIterable<Person> selected = people.selectWith((Person person, Integer age) -> person.getAge()>= age, Integer.valueOf(18));
Example using an anonymous inner class:
RichIterable<Person> selected = people.selectWith(new Predicate2<Person, Integer>() { public boolean accept(Person person, Integer age) { return person.getAge()>= age; } }, Integer.valueOf(18));
- Parameters:
predicate
- aPredicate2
to use as the select criteriaparameter
- a parameter to pass in for evaluation of the second argumentP
inpredicate
- Since:
- 5.0
- See Also:
select(Predicate)
-
selectWith
<P, R extends Collection<T>> R selectWith(Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)Similar toselect(Predicate, Collection)
, except with an evaluation parameter for the second generic argument inPredicate2
.E.g. return a
Collection
of Person elements where the person has an age greater than or equal to 18 yearsExample using a Java 8 lambda expression:
MutableList<Person> selected = people.selectWith((Person person, Integer age) -> person.getAge()>= age, Integer.valueOf(18), Lists.mutable.empty());
Example using an anonymous inner class:
MutableList<Person> selected = people.selectWith(new Predicate2<Person, Integer>() { public boolean accept(Person person, Integer age) { return person.getAge()>= age; } }, Integer.valueOf(18), Lists.mutable.empty());
- Parameters:
predicate
- aPredicate2
to use as the select criteriaparameter
- a parameter to pass in for evaluation of the second argumentP
inpredicate
targetCollection
- the Collection to append to for all elements in thisRichIterable
that meet select criteriapredicate
- Returns:
targetCollection
, which contains appended elements as a result of the select criteria- Since:
- 1.0
- See Also:
select(Predicate)
,select(Predicate, Collection)
-
reject
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)).Example using a Java 8 lambda expression:
RichIterable<Person> rejected = people.reject(person -> person.person.getLastName().equals("Smith"));
Example using an anonymous inner class:
RichIterable<Person> rejected = people.reject(new Predicate<Person>() { public boolean accept(Person person) { return person.person.getLastName().equals("Smith"); } });
- Parameters:
predicate
- aPredicate
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
Similar toreject(Predicate)
, except with an evaluation parameter for the second generic argument inPredicate2
.E.g. return a
Collection
of Person elements where the person has an age greater than or equal to 18 yearsExample using a Java 8 lambda expression:
RichIterable<Person> rejected = people.rejectWith((Person person, Integer age) -> person.getAge() < age, Integer.valueOf(18));
Example using an anonymous inner class:
MutableList<Person> rejected = people.rejectWith(new Predicate2<Person, Integer>() { public boolean accept(Person person, Integer age) { return person.getAge() < age; } }, Integer.valueOf(18));
- Parameters:
predicate
- aPredicate2
to use as the select criteriaparameter
- a parameter to pass in for evaluation of the second argumentP
inpredicate
- Since:
- 5.0
- See Also:
select(Predicate)
-
reject
Same as the reject method with one parameter but uses the specified target collection for the results.Example using a Java 8 lambda expression:
MutableList<Person> rejected = people.reject(person -> person.person.getLastName().equals("Smith"), Lists.mutable.empty());
Example using an anonymous inner class:
MutableList<Person> rejected = people.reject(new Predicate<Person>() { public boolean accept(Person person) { return person.person.getLastName().equals("Smith"); } }, Lists.mutable.empty());
- Parameters:
predicate
- aPredicate
to use as the reject criteriatarget
- the Collection to append to for all elements in thisRichIterable
that causePredicate#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 Collection<T>> R rejectWith(Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)Similar toreject(Predicate, Collection)
, except with an evaluation parameter for the second generic argument inPredicate2
.E.g. return a
Collection
of Person elements where the person has an age greater than or equal to 18 yearsExample using a Java 8 lambda expression:
MutableList<Person> rejected = people.rejectWith((Person person, Integer age) -> person.getAge() < age, Integer.valueOf(18), Lists.mutable.empty());
Example using an anonymous inner class:
MutableList<Person> rejected = people.rejectWith(new Predicate2<Person, Integer>() { public boolean accept(Person person, Integer age) { return person.getAge() < age; } }, Integer.valueOf(18), Lists.mutable.empty());
- Parameters:
predicate
- aPredicate2
to use as the reject criteriaparameter
- a parameter to pass in for evaluation of the second argumentP
inpredicate
targetCollection
- the Collection to append to for all elements in thisRichIterable
that causePredicate#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
Filters a collection into a PartitionedIterable based on the evaluation of the predicate.Example using a Java 8 lambda expression:
PartitionIterable<Person> newYorkersAndNonNewYorkers = people.partition(person -> person.getAddress().getState().getName().equals("New York"));
Example using an anonymous inner class:
PartitionIterable<Person> newYorkersAndNonNewYorkers = people.partition(new Predicate<Person>() { public boolean accept(Person person) { return person.getAddress().getState().getName().equals("New York"); } });
- Since:
- 1.0.
-
partitionWith
Filters a collection into a PartitionIterable based on the evaluation of the predicate.Example using a Java 8 lambda expression:
PartitionIterable<Person> newYorkersAndNonNewYorkers = people.partitionWith((Person person, String state) -> person.getAddress().getState().getName().equals(state), "New York");
Example using an anonymous inner class:
PartitionIterable<Person> newYorkersAndNonNewYorkers = 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
Returns all elements of the source collection that are instances of the Classclazz
.RichIterable<Integer> integers = List.mutable.with(new Integer(0), new Long(0L), new Double(0.0)).selectInstancesOf(Integer.class);
- Since:
- 2.0
-
collect
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.Example using a Java 8 lambda expression:
RichIterable<String> names = people.collect(person -> person.getFirstName() + " " + person.getLastName());
Example using an anonymous inner class:
RichIterable<String> names = people.collect(new Function<Person, String>() { public String valueOf(Person person) { return person.getFirstName() + " " + person.getLastName(); } });
- Since:
- 1.0
-
collect
Same ascollect(Function)
, except that the results are gathered into the specifiedtarget
collection.Example using a Java 8 lambda expression:
MutableList<String> names = people.collect(person -> person.getFirstName() + " " + person.getLastName(), Lists.mutable.empty());
Example using an anonymous inner class:
MutableList<String> names = people.collect(new Function<Person, String>() { public String valueOf(Person person) { return person.getFirstName() + " " + person.getLastName(); } }, Lists.mutable.empty());
- Parameters:
function
- aFunction
to use as the collect transformation functiontarget
- the Collection to append to for all elements in thisRichIterable
that meet select criteriafunction
- Returns:
target
, which contains appended elements as a result of the collect transformation- Since:
- 1.0
- See Also:
collect(Function)
-
collectBoolean
Returns a new primitiveboolean
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.Example using a Java 8 lambda expression:
BooleanIterable licenses = people.collectBoolean(person -> person.hasDrivingLicense());
Example using an anonymous inner class:
BooleanIterable licenses = 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 ascollectBoolean(BooleanFunction)
, except that the results are gathered into the specifiedtarget
collection.Example using a Java 8 lambda expression:
BooleanArrayList licenses = people.collectBoolean(person -> person.hasDrivingLicense(), new BooleanArrayList());
Example using an anonymous inner class:
BooleanArrayList licenses = people.collectBoolean(new BooleanFunction<Person>() { public boolean booleanValueOf(Person person) { return person.hasDrivingLicense(); } }, new BooleanArrayList());
- Parameters:
booleanFunction
- aBooleanFunction
to use as the collect transformation functiontarget
- the MutableBooleanCollection to append to for all elements in thisRichIterable
- Returns:
target
, which contains appended elements as a result of the collect transformation- Since:
- 5.0
-
collectByte
Returns a new primitivebyte
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.Example using a Java 8 lambda expression:
ByteIterable bytes = people.collectByte(person -> person.getCode());
Example using an anonymous inner class:
ByteIterable bytes = people.collectByte(new ByteFunction<Person>() { public byte byteValueOf(Person person) { return person.getCode(); } });
- Since:
- 4.0
-
collectByte
Same ascollectByte(ByteFunction)
, except that the results are gathered into the specifiedtarget
collection.Example using a Java 8 lambda expression:
ByteArrayList bytes = people.collectByte(person -> person.getCode(), new ByteArrayList());
Example using an anonymous inner class:
ByteArrayList bytes = people.collectByte(new ByteFunction<Person>() { public byte byteValueOf(Person person) { return person.getCode(); } }, new ByteArrayList());
- Parameters:
byteFunction
- aByteFunction
to use as the collect transformation functiontarget
- the MutableByteCollection to append to for all elements in thisRichIterable
- Returns:
target
, which contains appended elements as a result of the collect transformation- Since:
- 5.0
-
collectChar
Returns a new primitivechar
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.Example using a Java 8 lambda expression:
CharIterable chars = people.collectChar(person -> person.getMiddleInitial());
Example using an anonymous inner class:
CharIterable chars = people.collectChar(new CharFunction<Person>() { public char charValueOf(Person person) { return person.getMiddleInitial(); } });
- Since:
- 4.0
-
collectChar
Same ascollectChar(CharFunction)
, except that the results are gathered into the specifiedtarget
collection.Example using a Java 8 lambda expression:
CharArrayList chars = people.collectChar(person -> person.getMiddleInitial(), new CharArrayList());
Example using an anonymous inner class:
CharArrayList chars = people.collectChar(new CharFunction<Person>() { public char charValueOf(Person person) { return person.getMiddleInitial(); } }, new CharArrayList());
- Parameters:
charFunction
- aCharFunction
to use as the collect transformation functiontarget
- the MutableCharCollection to append to for all elements in thisRichIterable
- Returns:
target
, which contains appended elements as a result of the collect transformation- Since:
- 5.0
-
collectDouble
Returns a new primitivedouble
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.Example using a Java 8 lambda expression:
DoubleIterable doubles = people.collectDouble(person -> person.getMilesFromNorthPole());
Example using an anonymous inner class:
DoubleIterable doubles = 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 ascollectDouble(DoubleFunction)
, except that the results are gathered into the specifiedtarget
collection.Example using a Java 8 lambda expression:
DoubleArrayList doubles = people.collectDouble(person -> person.getMilesFromNorthPole(), new DoubleArrayList());
Example using an anonymous inner class:
DoubleArrayList doubles = people.collectDouble(new DoubleFunction<Person>() { public double doubleValueOf(Person person) { return person.getMilesFromNorthPole(); } }, new DoubleArrayList());
- Parameters:
doubleFunction
- aDoubleFunction
to use as the collect transformation functiontarget
- the MutableDoubleCollection to append to for all elements in thisRichIterable
- Returns:
target
, which contains appended elements as a result of the collect transformation- Since:
- 5.0
-
collectFloat
Returns a new primitivefloat
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.Example using a Java 8 lambda expression:
FloatIterable floats = people.collectFloat(person -> person.getHeightInInches());
Example using an anonymous inner class:
FloatIterable floats = 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 ascollectFloat(FloatFunction)
, except that the results are gathered into the specifiedtarget
collection.Example using a Java 8 lambda expression:
FloatArrayList floats = people.collectFloat(person -> person.getHeightInInches(), new FloatArrayList());
Example using an anonymous inner class:
FloatArrayList floats = people.collectFloat(new FloatFunction<Person>() { public float floatValueOf(Person person) { return person.getHeightInInches(); } }, new FloatArrayList());
- Parameters:
floatFunction
- aFloatFunction
to use as the collect transformation functiontarget
- the MutableFloatCollection to append to for all elements in thisRichIterable
- Returns:
target
, which contains appended elements as a result of the collect transformation- Since:
- 5.0
-
collectInt
Returns a new primitiveint
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.Example using a Java 8 lambda expression:
IntIterable ints = people.collectInt(person -> person.getAge());
Example using an anonymous inner class:
IntIterable ints = people.collectInt(new IntFunction<Person>() { public int intValueOf(Person person) { return person.getAge(); } });
- Since:
- 4.0
-
collectInt
Same ascollectInt(IntFunction)
, except that the results are gathered into the specifiedtarget
collection.Example using a Java 8 lambda expression:
IntArrayList ints = people.collectInt(person -> person.getAge(), new IntArrayList());
Example using an anonymous inner class:
IntArrayList ints = people.collectInt(new IntFunction<Person>() { public int intValueOf(Person person) { return person.getAge(); } }, new IntArrayList());
- Parameters:
intFunction
- aIntFunction
to use as the collect transformation functiontarget
- the MutableIntCollection to append to for all elements in thisRichIterable
- Returns:
target
, which contains appended elements as a result of the collect transformation- Since:
- 5.0
-
collectLong
Returns a new primitivelong
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.Example using a Java 8 lambda expression:
LongIterable longs = people.collectLong(person -> person.getGuid());
Example using an anonymous inner class:
LongIterable longs = people.collectLong(new LongFunction<Person>() { public long longValueOf(Person person) { return person.getGuid(); } });
- Since:
- 4.0
-
collectLong
Same ascollectLong(LongFunction)
, except that the results are gathered into the specifiedtarget
collection.Example using a Java 8 lambda expression:
LongArrayList longs = people.collectLong(person -> person.getGuid(), new LongArrayList());
Example using an anonymous inner class:
LongArrayList longs = people.collectLong(new LongFunction<Person>() { public long longValueOf(Person person) { return person.getGuid(); } }, new LongArrayList());
- Parameters:
longFunction
- aLongFunction
to use as the collect transformation functiontarget
- the MutableLongCollection to append to for all elements in thisRichIterable
- Returns:
target
, which contains appended elements as a result of the collect transformation- Since:
- 5.0
-
collectShort
Returns a new primitiveshort
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.Example using a Java 8 lambda expression:
ShortIterable shorts = people.collectShort(person -> person.getNumberOfJunkMailItemsReceivedPerMonth());
Example using an anonymous inner class:
ShortIterable shorts = 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 ascollectShort(ShortFunction)
, except that the results are gathered into the specifiedtarget
collection.Example using a Java 8 lambda expression:
ShortArrayList shorts = people.collectShort(person -> person.getNumberOfJunkMailItemsReceivedPerMonth, new ShortArrayList());
Example using an anonymous inner class:
ShortArrayList shorts = people.collectShort(new ShortFunction<Person>() { public short shortValueOf(Person person) { return person.getNumberOfJunkMailItemsReceivedPerMonth; } }, new ShortArrayList());
- Parameters:
shortFunction
- aShortFunction
to use as the collect transformation functiontarget
- the MutableShortCollection to append to for all elements in thisRichIterable
- Returns:
target
, which contains appended elements as a result of the collect transformation- Since:
- 5.0
-
collectWith
<P, V> RichIterable<V> collectWith(Function2<? super T,? super P,? extends V> function, P parameter)Same ascollect(Function)
with aFunction2
and specified parameter which is passed to the block.Example using a Java 8 lambda expression:
RichIterable<Integer> integers = Lists.mutable.with(1, 2, 3).collectWith((each, parameter) -> each + parameter, Integer.valueOf(1));
Example using an anonymous inner class:
Function2<Integer, Integer, Integer> addParameterFunction = new Function2<Integer, Integer, Integer>() { public Integer value(Integer each, Integer parameter) { return each + parameter; } }; RichIterable<Integer> integers = Lists.mutable.with(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1));
- Parameters:
function
- AFunction2
to use as the collect transformation functionparameter
- A parameter to pass in for evaluation of the second argumentP
infunction
- Returns:
- A new
RichIterable
that contains the transformed elements returned byFunction2.value(Object, Object)
- Since:
- 5.0
- See Also:
collect(Function)
-
collectWith
<P, V, R extends 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.Example using a Java 8 lambda expression:
MutableSet<Integer> integers = Lists.mutable.with(1, 2, 3).collectWith((each, parameter) -> each + parameter, Integer.valueOf(1), Sets.mutable.empty());
Example using an anonymous inner class:
Function2<Integer, Integer, Integer> addParameterFunction = new Function2<Integer, Integer, Integer>() { public Integer value(final Integer each, final Integer parameter) { return each + parameter; } }; MutableSet<Integer> integers = Lists.mutable.with(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1), Sets.mutable.empty());
- Parameters:
function
- aFunction2
to use as the collect transformation functionparameter
- a parameter to pass in for evaluation of the second argumentP
infunction
targetCollection
- the Collection to append to for all elements in thisRichIterable
that meet select criteriafunction
- 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).Example using a Java 8 lambda and method reference:
RichIterable<String> strings = Lists.mutable.with(1, 2, 3).collectIf(e -> e != null, Object::toString);
Example using Predicates factory:
RichIterable<String> strings = Lists.mutable.with(1, 2, 3).collectIf(Predicates.notNull(), Functions.getToString());
- Since:
- 1.0
-
collectIf
<V, R extends 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
- aPredicate
to use as the select criteriafunction
- aFunction
to use as the collect transformation functiontarget
- the Collection to append to for all elements in thisRichIterable
that meet the collect criteriapredicate
- Returns:
targetCollection
, which contains appended elements as a result of the collect criteria and transformation- Since:
- 1.0
- See Also:
collectIf(Predicate, Function)
-
flatCollect
flatCollect
is a special case ofcollect(Function)
. Withcollect
, when theFunction
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 eachPerson
has a list ofAddress
objects. Take the followingFunction
:Function<Person, List<Address>> addressFunction = Person::getAddresses; RichIterable<Person> people = ...;
Usingcollect
returns a collection of collections of addresses.RichIterable<List<Address>> addresses = people.collect(addressFunction);
UsingflatCollect
returns a single flattened list of addresses.RichIterable<Address> addresses = people.flatCollect(addressFunction);
- Parameters:
function
- TheFunction
to apply- Returns:
- a new flattened collection produced by applying the given
function
- Since:
- 1.0
-
flatCollectByte
default <R extends MutableByteCollection> R flatCollectByte(Function<? super T,? extends ByteIterable> function, R target)Same as flatCollect, only the results are collected into the target collection.- Parameters:
function
- TheFunction
to applytarget
- The collection into which results should be added.- Returns:
target
, which will contain a flattened collection of results produced by applying the givenfunction
- See Also:
flatCollect(Function)
-
flatCollectChar
default <R extends MutableCharCollection> R flatCollectChar(Function<? super T,? extends CharIterable> function, R target)Same as flatCollect, only the results are collected into the target collection.- Parameters:
function
- TheFunction
to applytarget
- The collection into which results should be added.- Returns:
target
, which will contain a flattened collection of results produced by applying the givenfunction
- See Also:
flatCollect(Function)
-
flatCollectInt
default <R extends MutableIntCollection> R flatCollectInt(Function<? super T,? extends IntIterable> function, R target)Same as flatCollect, only the results are collected into the target collection.- Parameters:
function
- TheFunction
to applytarget
- The collection into which results should be added.- Returns:
target
, which will contain a flattened collection of results produced by applying the givenfunction
- See Also:
flatCollect(Function)
-
flatCollectShort
default <R extends MutableShortCollection> R flatCollectShort(Function<? super T,? extends ShortIterable> function, R target)Same as flatCollect, only the results are collected into the target collection.- Parameters:
function
- TheFunction
to applytarget
- The collection into which results should be added.- Returns:
target
, which will contain a flattened collection of results produced by applying the givenfunction
- See Also:
flatCollect(Function)
-
flatCollectDouble
default <R extends MutableDoubleCollection> R flatCollectDouble(Function<? super T,? extends DoubleIterable> function, R target)Same as flatCollect, only the results are collected into the target collection.- Parameters:
function
- TheFunction
to applytarget
- The collection into which results should be added.- Returns:
target
, which will contain a flattened collection of results produced by applying the givenfunction
- See Also:
flatCollect(Function)
-
flatCollectFloat
default <R extends MutableFloatCollection> R flatCollectFloat(Function<? super T,? extends FloatIterable> function, R target)Same as flatCollect, only the results are collected into the target collection.- Parameters:
function
- TheFunction
to applytarget
- The collection into which results should be added.- Returns:
target
, which will contain a flattened collection of results produced by applying the givenfunction
- See Also:
flatCollect(Function)
-
flatCollectLong
default <R extends MutableLongCollection> R flatCollectLong(Function<? super T,? extends LongIterable> function, R target)Same as flatCollect, only the results are collected into the target collection.- Parameters:
function
- TheFunction
to applytarget
- The collection into which results should be added.- Returns:
target
, which will contain a flattened collection of results produced by applying the givenfunction
- See Also:
flatCollect(Function)
-
flatCollectBoolean
default <R extends MutableBooleanCollection> R flatCollectBoolean(Function<? super T,? extends BooleanIterable> function, R target)Same as flatCollect, only the results are collected into the target collection.- Parameters:
function
- TheFunction
to applytarget
- The collection into which results should be added.- Returns:
target
, which will contain a flattened collection of results produced by applying the givenfunction
- See Also:
flatCollect(Function)
-
flatCollectWith
default <P, V> RichIterable<V> flatCollectWith(Function2<? super T,? super P,? extends Iterable<V>> function, P parameter)- Since:
- 9.2
-
flatCollect
<V, R extends Collection<V>> R flatCollect(Function<? super T,? extends Iterable<V>> function, R target)Same as flatCollect, only the results are collected into the target collection.- Parameters:
function
- TheFunction
to applytarget
- The collection into which results should be added.- Returns:
target
, which will contain a flattened collection of results produced by applying the givenfunction
- See Also:
flatCollect(Function)
-
flatCollectWith
default <P, V, R extends Collection<V>> R flatCollectWith(Function2<? super T,? super P,? extends Iterable<V>> function, P parameter, R target)- Since:
- 9.2
-
detect
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.Example using a Java 8 lambda expression:
Person person = people.detect(person -> person.getFirstName().equals("John") && person.getLastName().equals("Smith"));
Example using an anonymous inner class:
Person person = people.detect(new Predicate<Person>() { public boolean accept(Person person) { return person.getFirstName().equals("John") && person.getLastName().equals("Smith"); } });
- Since:
- 1.0
-
detectWith
Returns the first element that evaluates to true for the specified predicate2 and parameter, or null if none evaluate to true.Example using a Java 8 lambda expression:
Person person = people.detectWith((person, fullName) -> person.getFullName().equals(fullName), "John Smith");
Example using an anonymous inner class:
Person person = people.detectWith(new Predicate2<Person, String>() { public boolean accept(Person person, String fullName) { return person.getFullName().equals(fullName); } }, "John Smith");
- Since:
- 5.0
-
detectOptional
Returns the first element of the iterable for which the predicate evaluates to true as an Optional. This method is commonly called find.Example using a Java 8 lambda expression:
Person person = people.detectOptional(person -> person.getFirstName().equals("John") && person.getLastName().equals("Smith"));
- Throws:
NullPointerException
- if the element selected is null- Since:
- 8.0
-
detectWithOptional
Returns the first element that evaluates to true for the specified predicate2 and parameter as an Optional.Example using a Java 8 lambda expression:
Optional<Person> person = people.detectWithOptional((person, fullName) -> person.getFullName().equals(fullName), "John Smith");
- Throws:
NullPointerException
- if the element selected is null- Since:
- 8.0
-
detectIfNone
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
Return the total number of elements that answer true to the specified predicate.Example using a Java 8 lambda expression:
int count = people.count(person -> person.getAddress().getState().getName().equals("New York"));
Example using an anonymous inner class:
int count = people.count(new Predicate<Person>() { public boolean accept(Person person) { return person.getAddress().getState().getName().equals("New York"); } });
- Since:
- 1.0
-
countWith
Returns the total number of elements that evaluate to true for the specified predicate.e.g. return lastNames.countWith(Predicates2.equal(), "Smith");
-
anySatisfy
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
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
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
Returns true if the predicate evaluates to true for every element of the collection, or returns false.- Since:
- 5.0
-
noneSatisfy
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
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
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
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
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
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
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
-
into
Adds all the elements in this iterable to the specific target Collection.- Since:
- 8.0
-
toList
MutableList<T> toList()Converts the collection to a MutableList implementation.- Since:
- 1.0
-
toSortedList
Converts the collection to a MutableList implementation and sorts it using the natural order of the elements.- Since:
- 1.0
-
toSortedList
Converts the collection to a MutableList implementation and sorts it using the specified comparator.- Since:
- 1.0
-
toSortedListBy
default <V extends 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 byfunction
.- 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
Converts the collection to a MutableSortedSet implementation and sorts it using the specified comparator.- Since:
- 1.0
-
toSortedSetBy
default <V extends 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 byfunction
.- Since:
- 1.0
-
toBag
MutableBag<T> toBag()Converts the collection to the default MutableBag implementation.- Since:
- 1.0
-
toSortedBag
MutableSortedBag<T> toSortedBag()Converts the collection to a MutableSortedBag implementation and sorts it using the natural order of the elements.- Since:
- 6.0
-
toSortedBag
Converts the collection to the MutableSortedBag implementation and sorts it using the specified comparator.- Since:
- 6.0
-
toSortedBagBy
default <V extends Comparable<? super V>> MutableSortedBag<T> toSortedBagBy(Function<? super T,? extends V> function)Converts the collection to a MutableSortedBag implementation and sorts it based on the natural order of the attribute returned byfunction
.- Since:
- 6.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
-
toMap
default <NK, NV, R extends Map<NK, NV>> R toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction, R target)Same astoMap(Function, Function)
, except that the results are gathered into the specifiedtarget
map.- Since:
- 10.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(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
-
toSortedMapBy
default <KK extends Comparable<? super KK>, NK, NV> MutableSortedMap<NK,NV> toSortedMapBy(Function<? super NK,KK> sortBy, 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 and sorts it based on the natural order of the attribute returned bysortBy
function. -
toBiMap
<NK, NV> MutableBiMap<NK,NV> toBiMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)Converts the collection to a BiMap implementation using the specified key and value functions.- Since:
- 10.0
-
asLazy
LazyIterable<T> asLazy()Returns a lazy (deferred) iterable, most likely implemented by calling LazyIterate.adapt(this).- Since:
- 1.0.
-
toArray
Object[] toArray()Converts this iterable to an array.- Since:
- 1.0
- See Also:
Collection.toArray()
-
toArray
<E> E[] toArray(E[] array)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
Returns the minimum element out of this container based on the comparator.- Throws:
NoSuchElementException
- if the RichIterable is empty- Since:
- 1.0
-
max
Returns the maximum element out of this container based on the comparator.- Throws:
NoSuchElementException
- if the RichIterable is empty- Since:
- 1.0
-
minOptional
Returns the minimum element out of this container based on the comparator as an Optional. If the container is emptyOptional.empty()
is returned.- Throws:
NullPointerException
- if the minimum element is null- Since:
- 8.2
-
maxOptional
Returns the maximum element out of this container based on the comparator as an Optional. If the container is emptyOptional.empty()
is returned.- Throws:
NullPointerException
- if the maximum element is null- Since:
- 8.2
-
min
T min()Returns the minimum element out of this container based on the natural order.- Throws:
ClassCastException
- if the elements are notComparable
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:
ClassCastException
- if the elements are notComparable
NoSuchElementException
- if the RichIterable is empty- Since:
- 1.0
-
minOptional
Returns the minimum element out of this container based on the natural order as an Optional. If the container is emptyOptional.empty()
is returned.- Throws:
ClassCastException
- if the elements are notComparable
NullPointerException
- if the minimum element is null- Since:
- 8.2
-
maxOptional
Returns the maximum element out of this container based on the natural order as an Optional. If the container is emptyOptional.empty()
is returned.- Throws:
ClassCastException
- if the elements are notComparable
NullPointerException
- if the maximum element is null- Since:
- 8.2
-
minBy
Returns the minimum elements out of this container based on the natural order of the attribute returned by Function.- Throws:
NoSuchElementException
- if the RichIterable is empty- Since:
- 1.0
-
maxBy
Returns the maximum elements out of this container based on the natural order of the attribute returned by Function.- Throws:
NoSuchElementException
- if the RichIterable is empty- Since:
- 1.0
-
minByOptional
default <V extends Comparable<? super V>> Optional<T> minByOptional(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 as an Optional. If the container is emptyOptional.empty()
is returned.- Throws:
NullPointerException
- if the minimum element is null- Since:
- 8.2
-
maxByOptional
default <V extends Comparable<? super V>> Optional<T> maxByOptional(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 as an Optional. If the container is emptyOptional.empty()
is returned.- Throws:
NullPointerException
- if the maximum element is null- Since:
- 8.2
-
sumOfInt
Returns the final long result of evaluating function for each element of the iterable and adding the results together.- Since:
- 2.0
-
sumOfFloat
Returns the final double result of evaluating function for each element of the iterable and adding the results together. It uses Kahan summation algorithm to reduce numerical error.- Since:
- 2.0
-
sumOfLong
Returns the final long result of evaluating function for each element of the iterable and adding the results together.- Since:
- 2.0
-
sumOfDouble
Returns the final double result of evaluating function for each element of the iterable and adding the results together. It uses Kahan summation algorithm to reduce numerical error.- Since:
- 2.0
-
summarizeInt
Returns the result of summarizing the value returned from applying the IntFunction to each element of the iterable.IntSummaryStatistics stats = Lists.mutable.with(1, 2, 3).summarizeInt(Integer::intValue);
- Since:
- 8.0
-
summarizeFloat
Returns the result of summarizing the value returned from applying the FloatFunction to each element of the iterable.DoubleSummaryStatistics stats = Lists.mutable.with(1, 2, 3).summarizeFloat(Integer::floatValue);
- Since:
- 8.0
-
summarizeLong
Returns the result of summarizing the value returned from applying the LongFunction to each element of the iterable.LongSummaryStatistics stats = Lists.mutable.with(1, 2, 3).summarizeLong(Integer::longValue);
- Since:
- 8.0
-
summarizeDouble
Returns the result of summarizing the value returned from applying the DoubleFunction to each element of the iterable.DoubleSummaryStatistics stats = Lists.mutable.with(1, 2, 3).summarizeDouble(Integer::doubleValue);
- Since:
- 8.0
-
reduceInPlace
This method produces the equivalent result asStream.collect(Collector)
.MutableObjectLongMap<Integer> map2 = Lists.mutable.with(1, 2, 3, 4, 5).reduceInPlace(Collectors2.sumByInt(i -> Integer.valueOf(i % 2), Integer::intValue));
- Since:
- 8.0
-
reduceInPlace
This method produces the equivalent result asStream.collect(Supplier, BiConsumer, BiConsumer)
. The combiner used in collect is unnecessary in the serial case, so is not included in the API.- Since:
- 8.0
-
reduce
This method produces the equivalent result asStream.reduce(BinaryOperator)
.- Since:
- 8.0
-
sumByInt
<V> ObjectLongMap<V> sumByInt(Function<? super T,? extends V> groupBy, IntFunction<? super T> function)Groups and sums the values using the two specified functions.- Since:
- 6.0
-
sumByFloat
<V> ObjectDoubleMap<V> sumByFloat(Function<? super T,? extends V> groupBy, FloatFunction<? super T> function)Groups and sums the values using the two specified functions.- Since:
- 6.0
-
sumByLong
<V> ObjectLongMap<V> sumByLong(Function<? super T,? extends V> groupBy, LongFunction<? super T> function)Groups and sums the values using the two specified functions.- Since:
- 6.0
-
sumByDouble
<V> ObjectDoubleMap<V> sumByDouble(Function<? super T,? extends V> groupBy, DoubleFunction<? super T> function)Groups and sums the values using the two specified functions.- Since:
- 6.0
-
makeString
Returns a string representation of this collection by delegating tomakeString(String)
and defaulting the separator parameter to the characters", "
(comma and space).- Returns:
- a string representation of this collection.
- Since:
- 1.0
-
makeString
Returns a string representation of this collection by delegating tomakeString(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
Returns a string representation of this collection with the elements separated by the specified separator and enclosed between the start and end strings.- Returns:
- a string representation of this collection.
- Since:
- 1.0
-
appendString
Prints a string representation of this collection onto the givenAppendable
. Prints the string returned bymakeString()
.- Since:
- 1.0
-
appendString
Prints a string representation of this collection onto the givenAppendable
. Prints the string returned bymakeString(String)
.- Since:
- 1.0
-
appendString
Prints a string representation of this collection onto the givenAppendable
. Prints the string returned bymakeString(String, String, String)
.- Since:
- 1.0
-
groupBy
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.Example using a Java 8 method reference:
Multimap<String, Person> peopleByLastName = people.groupBy(Person::getLastName);
Example using an anonymous inner class:
Multimap<String, Person> peopleByLastName = people.groupBy(new Function<Person, String>() { public String valueOf(Person person) { return person.getLastName(); } });
- Since:
- 1.0
-
countBy
This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.- Since:
- 9.0
-
countBy
default <V, R extends MutableBagIterable<V>> R countBy(Function<? super T,? extends V> function, R target)This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.- Since:
- 9.0
-
countByWith
default <V, P> Bag<V> countByWith(Function2<? super T,? super P,? extends V> function, P parameter)This method will count the number of occurrences of each value calculated by applying the function to each element of the collection with the specified parameter as the second argument.- Since:
- 9.0
-
countByWith
default <V, P, R extends MutableBagIterable<V>> R countByWith(Function2<? super T,? super P,? extends V> function, P parameter, R target)This method will count the number of occurrences of each value calculated by applying the function to each element of the collection with the specified parameter as the second argument.- Since:
- 9.0
-
countByEach
This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.- Since:
- 10.0.0
-
countByEach
default <V, R extends MutableBagIterable<V>> R countByEach(Function<? super T,? extends Iterable<V>> function, R target)This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.- Since:
- 10.0.0
-
groupBy
<V, R extends MutableMultimap<V, T>> R groupBy(Function<? super T,? extends V> function, R target)Same asgroupBy(Function)
, except that the results are gathered into the specifiedtarget
multimap.Example using a Java 8 method reference:
FastListMultimap<String, Person> peopleByLastName = people.groupBy(Person::getLastName, new FastListMultimap<String, Person>());
Example using an anonymous inner class:
FastListMultimap<String, Person> peopleByLastName = people.groupBy(new Function<Person, String>() { public String valueOf(Person person) { return person.getLastName(); } }, new FastListMultimap<String, Person>());
- Since:
- 1.0
-
groupByEach
Similar togroupBy(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 Iterable<V>> function, R target)Same asgroupByEach(Function)
, except that the results are gathered into the specifiedtarget
multimap.- Since:
- 1.0
-
groupByUniqueKey
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:
IllegalStateException
- if the keys returned by the function are not unique- Since:
- 5.0
- See Also:
groupBy(Function)
-
groupByUniqueKey
<V, R extends MutableMapIterable<V, T>> R groupByUniqueKey(Function<? super T,? extends V> function, R target)Same asgroupByUniqueKey(Function)
, except that the results are gathered into the specifiedtarget
map.- Throws:
IllegalStateException
- if the keys returned by the function are not unique- Since:
- 6.0
- See Also:
groupByUniqueKey(Function)
-
toString
String toString()Returns a string with the elements of this iterable separated by commas with spaces and enclosed in square brackets.Assert.assertEquals("[]", Lists.mutable.empty().toString()); Assert.assertEquals("[1]", Lists.mutable.with(1).toString()); Assert.assertEquals("[1, 2, 3]", Lists.mutable.with(1, 2, 3).toString());
- Overrides:
toString
in classObject
- Returns:
- a string representation of this RichIterable
- Since:
- 1.0
- See Also:
AbstractCollection.toString()
-
zip
Deprecated.in 6.0. UseOrderedIterable.zip(Iterable)
instead.Returns aRichIterable
formed from thisRichIterable
and anotherRichIterable
by combining corresponding elements in pairs. If one of the twoRichIterable
s 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
- TheRichIterable
providing the second half of each result pair- Returns:
- A new
RichIterable
containing pairs consisting of corresponding elements of thisRichIterable
and that. The length of the returnedRichIterable
is the minimum of the lengths of thisRichIterable
and that. - Since:
- 1.0
-
zip
Deprecated.in 6.0. UseOrderedIterable.zip(Iterable, Collection)
instead;Same aszip(Iterable)
but usestarget
for output.- Since:
- 1.0
-
zipWithIndex
Deprecated.in 6.0. UseOrderedIterable.zipWithIndex()
instead.Zips thisRichIterable
with its indices.- Returns:
- A new
RichIterable
containing pairs consisting of all elements of thisRichIterable
paired with their index. Indices start at 0. - Since:
- 1.0
- See Also:
zip(Iterable)
-
zipWithIndex
Deprecated.in 6.0. UseOrderedIterable.zipWithIndex(Collection)
instead.Same aszipWithIndex()
but usestarget
for output.- Since:
- 1.0
-
chunk
Partitions elements in fixed size chunks.- Parameters:
size
- the number of elements per chunk- Returns:
- A
RichIterable
containingRichIterable
s of sizesize
, except the last will be truncated if the elements don't divide evenly. - Since:
- 1.0
-
aggregateInPlaceBy
default <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
default <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
-
aggregateBy
default <K, V, R extends MutableMapIterable<K, V>> R aggregateBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator, R target)Applies an aggregate function over the iterable grouping results into the target 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:
- 10.3
-
groupByAndCollect
default <K, V, R extends MutableMultimap<K, V>> R groupByAndCollect(Function<? super T,? extends K> groupByFunction, Function<? super T,? extends V> collectFunction, R target)Applies a groupBy function over the iterable, followed by a collect function.- Parameters:
groupByFunction
- aFunction
to use as the groupBy transformation functioncollectFunction
- aFunction
to use as the collect transformation function- Returns:
- The
target
collection where the key is the transformed result from applying the groupBy function and the value is the transformed result from applying the collect function. - Since:
- 10.1.0
- See Also:
groupBy(Function)
,Multimap.collectValues(Function)
-