Package org.eclipse.collections.impl.utility.internal

Class RandomAccessListIterate

java.lang.Object

org.eclipse.collections.impl.utility.internal.RandomAccessListIterate

public final class RandomAccessListIterate
extends Object

The ListIterate class provides a few of the methods from the Smalltalk Collection Protocol for use with ArrayLists. This includes do:, select:, reject:, collect:, inject:into:, detect:, detect:ifNone:, anySatisfy: and allSatisfy:

Method Summary

Modifier and Type	Method	Description
static <T,K,V> MutableMap<K,V>	aggregateBy(List<T> list, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
static <T,K,V> MutableMap<K,V>	aggregateInPlaceBy(List<T> list, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
static <T> boolean	allSatisfy(List<T> list, Predicate<? super T> predicate)
static <T,P> boolean	allSatisfyWith(List<T> list, Predicate2<? super T,? super P> predicate, P parameter)
static <T> boolean	anySatisfy(List<T> list, Predicate<? super T> predicate)
static <T,P> boolean	anySatisfyWith(List<T> list, Predicate2<? super T,? super P> predicate, P parameter)
static <T> void	appendString(List<T> list, Appendable appendable, String start, String separator, String end)
static <T,A> MutableList<A>	collect(List<T> list, Function<? super T,? extends A> function)
static <T,A,R extends Collection<A>> R	collect(List<T> list, Function<? super T,? extends A> function, R targetCollection)
static <T> MutableBooleanList	collectBoolean(List<T> list, BooleanFunction<? super T> booleanFunction)
static <T,R extends MutableBooleanCollection> R	collectBoolean(List<T> list, BooleanFunction<? super T> booleanFunction, R target)
static <T> MutableByteList	collectByte(List<T> list, ByteFunction<? super T> byteFunction)
static <T,R extends MutableByteCollection> R	collectByte(List<T> list, ByteFunction<? super T> byteFunction, R target)
static <T> MutableCharList	collectChar(List<T> list, CharFunction<? super T> charFunction)
static <T,R extends MutableCharCollection> R	collectChar(List<T> list, CharFunction<? super T> charFunction, R target)
static <T> MutableDoubleList	collectDouble(List<T> list, DoubleFunction<? super T> doubleFunction)
static <T,R extends MutableDoubleCollection> R	collectDouble(List<T> list, DoubleFunction<? super T> doubleFunction, R target)
static <T> MutableFloatList	collectFloat(List<T> list, FloatFunction<? super T> floatFunction)
static <T,R extends MutableFloatCollection> R	collectFloat(List<T> list, FloatFunction<? super T> floatFunction, R target)
static <T,A> MutableList<A>	collectIf(List<T> list, Predicate<? super T> predicate, Function<? super T,? extends A> function)
static <T,A,R extends Collection<A>> R	collectIf(List<T> list, Predicate<? super T> predicate, Function<? super T,? extends A> function, R targetCollection)
static <T> MutableIntList	collectInt(List<T> list, IntFunction<? super T> intFunction)
static <T,R extends MutableIntCollection> R	collectInt(List<T> list, IntFunction<? super T> intFunction, R target)
static <T> MutableLongList	collectLong(List<T> list, LongFunction<? super T> longFunction)
static <T,R extends MutableLongCollection> R	collectLong(List<T> list, LongFunction<? super T> longFunction, R target)
static <T> MutableShortList	collectShort(List<T> list, ShortFunction<? super T> shortFunction)
static <T,R extends MutableShortCollection> R	collectShort(List<T> list, ShortFunction<? super T> shortFunction, R target)
static <T,P,A,R extends Collection<A>> R	collectWith(List<T> list, Function2<? super T,? super P,? extends A> function, P parameter, R targetCollection)
static <T,A> MutableList<A>	collectWithIndex(List<T> list, ObjectIntToObjectFunction<? super T,? extends A> function)
static <T,A,R extends Collection<A>> R	collectWithIndex(List<T> list, ObjectIntToObjectFunction<? super T,? extends A> function, R targetCollection)
static <T,P> boolean	corresponds(List<T> list, OrderedIterable<P> other, Predicate2<? super T,? super P> predicate)
static <T> int	count(List<T> list, Predicate<? super T> predicate)
static <T,IV> int	countWith(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)
static <T> T	detect(List<T> list, Predicate<? super T> predicate)
static <T> int	detectIndex(List<T> list, Predicate<? super T> predicate)	Searches for the first occurrence where the predicate evaluates to true.
static <T,IV> int	detectIndexWith(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)	Searches for the first occurrence where the predicate evaluates to true.
static <T> int	detectLastIndex(List<T> list, Predicate<? super T> predicate)
static <T> Optional<T>	detectOptional(List<T> list, Predicate<? super T> predicate)
static <T,P> T	detectWith(List<T> list, Predicate2<? super T,? super P> predicate, P parameter)
static <T,P> Optional<T>	detectWithOptional(List<T> list, Predicate2<? super T,? super P> predicate, P parameter)
static <T> MutableList<T>	distinct(List<T> list)
static <T> MutableList<T>	distinct(List<T> list, HashingStrategy<? super T> hashingStrategy)
static <T,R extends List<T>> R	distinct(List<T> list, R targetList)	Deprecated. in 7.0.
static <T> MutableList<T>	drop(List<T> list, int count)
static <T,R extends Collection<T>> R	drop(List<T> list, int count, R targetList)
static <T> MutableList<T>	dropWhile(List<T> list, Predicate<? super T> predicate)
static <T,A> MutableList<A>	flatCollect(List<T> list, Function<? super T,? extends Iterable<A>> function)
static <T,A,R extends Collection<A>> R	flatCollect(List<T> list, Function<? super T,? extends Iterable<A>> function, R targetCollection)
static <T> void	forEach(List<T> list, int from, int to, Procedure<? super T> procedure)	Iterates over the section of the list covered by the specified indexes.
static <T> void	forEach(List<T> list, Procedure<? super T> procedure)
static <T1,T2> void	forEachInBoth(List<T1> list1, List<T2> list2, Procedure2<? super T1,? super T2> procedure)	For each element in both of the Lists, operation is evaluated with both elements as parameters.
static <T,P> void	forEachWith(List<T> list, Procedure2<? super T,? super P> procedure, P parameter)
static <T> void	forEachWithIndex(List<T> list, int from, int to, ObjectIntProcedure<? super T> objectIntProcedure)	Iterates over the section of the list covered by the specified indexes.
static <T> void	forEachWithIndex(List<T> list, ObjectIntProcedure<? super T> objectIntProcedure)	Iterates over a collection passing each element and the current relative int index to the specified instance of ObjectIntProcedure.
static <T> T	getLast(List<T> collection)	Returns the last element of a list.
static <T,V> FastListMultimap<V,T>	groupBy(List<T> list, Function<? super T,? extends V> function)
static <T,V,R extends MutableMultimap<V,T>> R	groupBy(List<T> list, Function<? super T,? extends V> function, R target)
static <T,V> FastListMultimap<V,T>	groupByEach(List<T> list, Function<? super T,? extends Iterable<V>> function)
static <T,V,R extends MutableMultimap<V,T>> R	groupByEach(List<T> list, Function<? super T,? extends Iterable<V>> function, R target)
static <K,T> MutableMap<K,T>	groupByUniqueKey(List<T> list, Function<? super T,? extends K> function)
static <K,T,R extends MutableMapIterable<K,T>> R	groupByUniqueKey(List<T> list, Function<? super T,? extends K> function, R target)
static <T> double	injectInto(double injectValue, List<T> list, DoubleObjectToDoubleFunction<? super T> function)
static <T> float	injectInto(float injectValue, List<T> list, FloatObjectToFloatFunction<? super T> function)
static <T> int	injectInto(int injectValue, List<T> list, IntObjectToIntFunction<? super T> function)
static <T> long	injectInto(long injectValue, List<T> list, LongObjectToLongFunction<? super T> function)
static <T,IV> IV	injectInto(IV injectValue, List<T> list, Function2<? super IV,? super T,? extends IV> function)
static <T,IV,P> IV	injectIntoWith(IV injectedValue, List<T> list, Function3<? super IV,? super T,? super P,? extends IV> function, P parameter)
static <T> T	max(List<T> list)
static <T> T	max(List<T> list, Comparator<? super T> comparator)
static <T,V extends Comparable<? super V>> T	maxBy(List<T> list, Function<? super T,? extends V> function)
static <T> T	min(List<T> list)
static <T> T	min(List<T> list, Comparator<? super T> comparator)
static <T,V extends Comparable<? super V>> T	minBy(List<T> list, Function<? super T,? extends V> function)
static <T> boolean	noneSatisfy(List<T> list, Predicate<? super T> predicate)
static <T,P> boolean	noneSatisfyWith(List<T> list, Predicate2<? super T,? super P> predicate, P parameter)
static <T> PartitionMutableList<T>	partition(List<T> list, Predicate<? super T> predicate)
static <T> PartitionMutableList<T>	partitionWhile(List<T> list, Predicate<? super T> predicate)
static <T,P> PartitionMutableList<T>	partitionWith(List<T> list, Predicate2<? super T,? super P> predicate, P parameter)
static <T> MutableList<T>	reject(List<T> list, Predicate<? super T> predicate)
static <T,R extends Collection<T>> R	reject(List<T> list, Predicate<? super T> predicate, R targetCollection)
static <T,IV> MutableList<T>	rejectWith(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)
static <T,P,R extends Collection<T>> R	rejectWith(List<T> list, Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)
static <T> boolean	removeIf(List<T> list, Predicate<? super T> predicate)
static <T> boolean	removeIf(List<T> list, Predicate<? super T> predicate, Procedure<? super T> procedure)
static <T,P> boolean	removeIfWith(List<T> list, Predicate2<? super T,? super P> predicate, P parameter)
static <T,P> boolean	removeIfWith(List<T> list, Predicate2<? super T,? super P> predicate, P parameter, Procedure<? super T> procedure)
static <T> MutableList<T>	select(List<T> list, Predicate<? super T> predicate)
static <T,R extends Collection<T>> R	select(List<T> list, Predicate<? super T> predicate, R targetCollection)
static <T,IV> Twin<MutableList<T>>	selectAndRejectWith(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)
static <T> MutableList<T>	selectInstancesOf(List<?> list, Class<T> clazz)
static <T,IV> MutableList<T>	selectWith(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)
static <T,P,R extends Collection<T>> R	selectWith(List<T> list, Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)
static <T> boolean	shortCircuit(List<T> list, Predicate<? super T> predicate, boolean expected, boolean onShortCircuit, boolean atEnd)
static <T,P> boolean	shortCircuitWith(List<T> list, Predicate2<? super T,? super P> predicate2, P parameter, boolean expected, boolean onShortCircuit, boolean atEnd)
static <V,T> MutableMap<V,BigDecimal>	sumByBigDecimal(List<T> list, Function<? super T,? extends V> groupBy, Function<? super T,BigDecimal> function)
static <V,T> MutableMap<V,BigInteger>	sumByBigInteger(List<T> list, Function<? super T,? extends V> groupBy, Function<? super T,BigInteger> function)
static <V,T> ObjectDoubleMap<V>	sumByDouble(List<T> list, Function<? super T,? extends V> groupBy, DoubleFunction<? super T> function)
static <V,T> ObjectDoubleMap<V>	sumByFloat(List<T> list, Function<? super T,? extends V> groupBy, FloatFunction<? super T> function)
static <V,T> ObjectLongMap<V>	sumByInt(List<T> list, Function<? super T,? extends V> groupBy, IntFunction<? super T> function)
static <V,T> ObjectLongMap<V>	sumByLong(List<T> list, Function<? super T,? extends V> groupBy, LongFunction<? super T> function)
static <T> BigDecimal	sumOfBigDecimal(List<T> list, Function<? super T,BigDecimal> function)
static <T> BigInteger	sumOfBigInteger(List<T> list, Function<? super T,BigInteger> function)
static <T> double	sumOfDouble(List<T> list, DoubleFunction<? super T> function)
static <T> double	sumOfFloat(List<T> list, FloatFunction<? super T> function)
static <T> long	sumOfInt(List<T> list, IntFunction<? super T> function)
static <T> long	sumOfLong(List<T> list, LongFunction<? super T> function)
static <T> MutableList<T>	take(List<T> list, int count)
static <T,R extends Collection<T>> R	take(List<T> list, int count, R targetList)
static <T> MutableList<T>	takeWhile(List<T> list, Predicate<? super T> predicate)
static <T> void	toArray(List<T> list, T[] target, int startIndex, int sourceSize)
static <X,Y> MutableList<Pair<X,Y>>	zip(List<X> list, Iterable<Y> iterable)
static <X,Y,R extends Collection<Pair<X,Y>>> R	zip(List<X> list, Iterable<Y> iterable, R target)
static <T> MutableList<Pair<T,Integer>>	zipWithIndex(List<T> list)
static <T,R extends Collection<Pair<T,Integer>>> R	zipWithIndex(List<T> list, R target)

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

toArray

public static <T> void toArray(List<T> list,
                               T[] target,
                               int startIndex,
                               int sourceSize)

select

public static <T> MutableList<T> select(List<T> list,
                                        Predicate<? super T> predicate)

See Also:

Iterate.select(Iterable, Predicate)

selectWith

public static <T,IV> MutableList<T> selectWith(List<T> list,
                                                     Predicate2<? super T,? super IV> predicate,
                                                     IV injectedValue)

See Also:

Iterate.selectWith(Iterable, Predicate2, Object)

select

public static <T,R extends Collection<T>> R select(List<T> list,
                                                         Predicate<? super T> predicate,
                                                         R targetCollection)

See Also:

Iterate.select(Iterable, Predicate, Collection)

selectWith

public static <T,P,R extends Collection<T>> R selectWith(List<T> list,
                                                                     Predicate2<? super T,? super P> predicate,
                                                                     P parameter,
                                                                     R targetCollection)

See Also:

Iterate.selectWith(Iterable, Predicate2, Object, Collection)

selectInstancesOf

public static <T> MutableList<T> selectInstancesOf(List<?> list,
                                                   Class<T> clazz)

See Also:

Iterate.selectInstancesOf(Iterable, Class)

count

public static <T> int count(List<T> list,
                            Predicate<? super T> predicate)

See Also:

Iterate.count(Iterable, Predicate)

countWith

public static <T,IV> int countWith(List<T> list,
                                         Predicate2<? super T,? super IV> predicate,
                                         IV injectedValue)

collectIf

public static <T,A> MutableList<A> collectIf(List<T> list,
                                                   Predicate<? super T> predicate,
                                                   Function<? super T,? extends A> function)

See Also:

Iterate.collectIf(Iterable, Predicate, Function)

collectIf

public static <T,A,R extends Collection<A>> R collectIf(List<T> list,
                                                                    Predicate<? super T> predicate,
                                                                    Function<? super T,? extends A> function,
                                                                    R targetCollection)

See Also:

Iterate.collectIf(Iterable, Predicate, Function, Collection)

reject

public static <T> MutableList<T> reject(List<T> list,
                                        Predicate<? super T> predicate)

See Also:

Iterate.reject(Iterable, Predicate)

rejectWith

public static <T,IV> MutableList<T> rejectWith(List<T> list,
                                                     Predicate2<? super T,? super IV> predicate,
                                                     IV injectedValue)

See Also:

Iterate.rejectWith(Iterable, Predicate2, Object)

reject

public static <T,R extends Collection<T>> R reject(List<T> list,
                                                         Predicate<? super T> predicate,
                                                         R targetCollection)

See Also:

Iterate.reject(Iterable, Predicate, Collection)

rejectWith

public static <T,P,R extends Collection<T>> R rejectWith(List<T> list,
                                                                     Predicate2<? super T,? super P> predicate,
                                                                     P parameter,
                                                                     R targetCollection)

See Also:

Iterate.reject(Iterable, Predicate, Collection)

collect

public static <T,A> MutableList<A> collect(List<T> list,
                                                 Function<? super T,? extends A> function)

See Also:

Iterate.collect(Iterable, Function)

collect

public static <T,A,R extends Collection<A>> R collect(List<T> list,
                                                                  Function<? super T,? extends A> function,
                                                                  R targetCollection)

See Also:

Iterate.collect(Iterable, Function, Collection)

collectWithIndex

public static <T,A> MutableList<A> collectWithIndex(List<T> list,
                                                          ObjectIntToObjectFunction<? super T,? extends A> function)

Since:

9.1

collectWithIndex

public static <T,A,R extends Collection<A>> R collectWithIndex(List<T> list,
                                                                           ObjectIntToObjectFunction<? super T,? extends A> function,
                                                                           R targetCollection)

Since:

9.1

collectBoolean

public static <T> MutableBooleanList collectBoolean(List<T> list,
                                                    BooleanFunction<? super T> booleanFunction)

See Also:

Iterate.collectBoolean(Iterable, BooleanFunction)

collectBoolean

public static <T,R extends MutableBooleanCollection> R collectBoolean(List<T> list,
                                                                            BooleanFunction<? super T> booleanFunction,
                                                                            R target)

See Also:

Iterate.collectBoolean(Iterable, BooleanFunction)

collectByte

public static <T> MutableByteList collectByte(List<T> list,
                                              ByteFunction<? super T> byteFunction)

See Also:

Iterate.collectByte(Iterable, ByteFunction)

collectByte

public static <T,R extends MutableByteCollection> R collectByte(List<T> list,
                                                                      ByteFunction<? super T> byteFunction,
                                                                      R target)

See Also:

Iterate.collectByte(Iterable, ByteFunction)

collectChar

public static <T> MutableCharList collectChar(List<T> list,
                                              CharFunction<? super T> charFunction)

See Also:

Iterate.collectChar(Iterable, CharFunction)

collectChar

public static <T,R extends MutableCharCollection> R collectChar(List<T> list,
                                                                      CharFunction<? super T> charFunction,
                                                                      R target)

See Also:

Iterate.collectChar(Iterable, CharFunction)

collectDouble

public static <T> MutableDoubleList collectDouble(List<T> list,
                                                  DoubleFunction<? super T> doubleFunction)

See Also:

Iterate.collectDouble(Iterable, DoubleFunction)

collectDouble

public static <T,R extends MutableDoubleCollection> R collectDouble(List<T> list,
                                                                          DoubleFunction<? super T> doubleFunction,
                                                                          R target)

See Also:

Iterate.collectDouble(Iterable, DoubleFunction)

collectFloat

public static <T> MutableFloatList collectFloat(List<T> list,
                                                FloatFunction<? super T> floatFunction)

See Also:

Iterate.collectFloat(Iterable, FloatFunction)

collectFloat

public static <T,R extends MutableFloatCollection> R collectFloat(List<T> list,
                                                                        FloatFunction<? super T> floatFunction,
                                                                        R target)

See Also:

Iterate.collectFloat(Iterable, FloatFunction)

collectInt

public static <T> MutableIntList collectInt(List<T> list,
                                            IntFunction<? super T> intFunction)

See Also:

Iterate.collectInt(Iterable, IntFunction)

collectInt

public static <T,R extends MutableIntCollection> R collectInt(List<T> list,
                                                                    IntFunction<? super T> intFunction,
                                                                    R target)

See Also:

Iterate.collectInt(Iterable, IntFunction)

collectLong

public static <T> MutableLongList collectLong(List<T> list,
                                              LongFunction<? super T> longFunction)

See Also:

Iterate.collectLong(Iterable, LongFunction)

collectLong

public static <T,R extends MutableLongCollection> R collectLong(List<T> list,
                                                                      LongFunction<? super T> longFunction,
                                                                      R target)

See Also:

Iterate.collectLong(Iterable, LongFunction)

collectShort

public static <T> MutableShortList collectShort(List<T> list,
                                                ShortFunction<? super T> shortFunction)

See Also:

Iterate.collectShort(Iterable, ShortFunction)

collectShort

public static <T,R extends MutableShortCollection> R collectShort(List<T> list,
                                                                        ShortFunction<? super T> shortFunction,
                                                                        R target)

See Also:

Iterate.collectShort(Iterable, ShortFunction)

flatCollect

public static <T,A> MutableList<A> flatCollect(List<T> list,
                                                     Function<? super T,? extends Iterable<A>> function)

See Also:

Iterate.flatCollect(Iterable, Function)

flatCollect

public static <T,A,R extends Collection<A>> R flatCollect(List<T> list,
                                                                      Function<? super T,? extends Iterable<A>> function,
                                                                      R targetCollection)

See Also:

Iterate.flatCollect(Iterable, Function, Collection)

getLast

public static <T> T getLast(List<T> collection)

Returns the last element of a list.

forEach

public static <T> void forEach(List<T> list,
                               Procedure<? super T> procedure)

See Also:

Iterate.forEach(Iterable, Procedure)

forEach

public static <T> void forEach(List<T> list,
                               int from,
                               int to,
                               Procedure<? super T> procedure)

Iterates over the section of the list covered by the specified indexes. The indexes are both inclusive. If the from is less than the to, the list is iterated in forward order. If the from is greater than the to, then the list is iterated in the reverse order.

e.g.
 MutableList<People> people = FastList.newListWith(ted, mary, bob, sally);
 ListIterate.forEach(people, 0, 1, new Procedure<Person>()
 {
     public void value(Person person)
     {
          LOGGER.info(person.getName());
     }
 });
 

This code would output ted and mary's names.

forEachWithIndex

public static <T> void forEachWithIndex(List<T> list,
                                        int from,
                                        int to,
                                        ObjectIntProcedure<? super T> objectIntProcedure)

Iterates over the section of the list covered by the specified indexes. The indexes are both inclusive. If the from is less than the to, the list is iterated in forward order. If the from is greater than the to, then the list is iterated in the reverse order. The index passed into the ObjectIntProcedure is the actual index of the range.

e.g.
 MutableList<People> people = FastList.newListWith(ted, mary, bob, sally);
 ListIterate.forEachWithIndex(people, 0, 1, new ObjectIntProcedure<Person>()
 {
     public void value(Person person, int index)
     {
          LOGGER.info(person.getName() + " at index: " + index);
     }
 });
 

This code would output ted and mary's names.

forEachInBoth

public static <T1,T2> void forEachInBoth(List<T1> list1,
                                               List<T2> list2,
                                               Procedure2<? super T1,? super T2> procedure)

For each element in both of the Lists, operation is evaluated with both elements as parameters.

forEachWithIndex

public static <T> void forEachWithIndex(List<T> list,
                                        ObjectIntProcedure<? super T> objectIntProcedure)

Iterates over a collection passing each element and the current relative int index to the specified instance of ObjectIntProcedure.

injectInto

public static <T,IV> IV injectInto(IV injectValue,
                                         List<T> list,
                                         Function2<? super IV,? super T,? extends IV> function)

injectInto

public static <T> int injectInto(int injectValue,
                                 List<T> list,
                                 IntObjectToIntFunction<? super T> function)

injectInto

public static <T> long injectInto(long injectValue,
                                  List<T> list,
                                  LongObjectToLongFunction<? super T> function)

injectInto

public static <T> double injectInto(double injectValue,
                                    List<T> list,
                                    DoubleObjectToDoubleFunction<? super T> function)

injectInto

public static <T> float injectInto(float injectValue,
                                   List<T> list,
                                   FloatObjectToFloatFunction<? super T> function)

sumOfInt

public static <T> long sumOfInt(List<T> list,
                                IntFunction<? super T> function)

sumOfLong

public static <T> long sumOfLong(List<T> list,
                                 LongFunction<? super T> function)

sumOfFloat

public static <T> double sumOfFloat(List<T> list,
                                    FloatFunction<? super T> function)

sumOfDouble

public static <T> double sumOfDouble(List<T> list,
                                     DoubleFunction<? super T> function)

sumOfBigDecimal

public static <T> BigDecimal sumOfBigDecimal(List<T> list,
                                             Function<? super T,BigDecimal> function)

sumOfBigInteger

public static <T> BigInteger sumOfBigInteger(List<T> list,
                                             Function<? super T,BigInteger> function)

sumByBigDecimal

public static <V,T> MutableMap<V,BigDecimal> sumByBigDecimal(List<T> list,
                                                                         Function<? super T,? extends V> groupBy,
                                                                         Function<? super T,BigDecimal> function)

sumByBigInteger

public static <V,T> MutableMap<V,BigInteger> sumByBigInteger(List<T> list,
                                                                         Function<? super T,? extends V> groupBy,
                                                                         Function<? super T,BigInteger> function)

shortCircuit

public static <T> boolean shortCircuit(List<T> list,
                                       Predicate<? super T> predicate,
                                       boolean expected,
                                       boolean onShortCircuit,
                                       boolean atEnd)

shortCircuitWith

public static <T,P> boolean shortCircuitWith(List<T> list,
                                                   Predicate2<? super T,? super P> predicate2,
                                                   P parameter,
                                                   boolean expected,
                                                   boolean onShortCircuit,
                                                   boolean atEnd)

corresponds

public static <T,P> boolean corresponds(List<T> list,
                                              OrderedIterable<P> other,
                                              Predicate2<? super T,? super P> predicate)

anySatisfy

public static <T> boolean anySatisfy(List<T> list,
                                     Predicate<? super T> predicate)

anySatisfyWith

public static <T,P> boolean anySatisfyWith(List<T> list,
                                                 Predicate2<? super T,? super P> predicate,
                                                 P parameter)

allSatisfy

public static <T> boolean allSatisfy(List<T> list,
                                     Predicate<? super T> predicate)

allSatisfyWith

public static <T,P> boolean allSatisfyWith(List<T> list,
                                                 Predicate2<? super T,? super P> predicate,
                                                 P parameter)

noneSatisfy

public static <T> boolean noneSatisfy(List<T> list,
                                      Predicate<? super T> predicate)

noneSatisfyWith

public static <T,P> boolean noneSatisfyWith(List<T> list,
                                                  Predicate2<? super T,? super P> predicate,
                                                  P parameter)

detect

public static <T> T detect(List<T> list,
                           Predicate<? super T> predicate)

detectWith

public static <T,P> T detectWith(List<T> list,
                                       Predicate2<? super T,? super P> predicate,
                                       P parameter)

detectOptional

public static <T> Optional<T> detectOptional(List<T> list,
                                             Predicate<? super T> predicate)

detectWithOptional

public static <T,P> Optional<T> detectWithOptional(List<T> list,
                                                         Predicate2<? super T,? super P> predicate,
                                                         P parameter)

selectAndRejectWith

public static <T,IV> Twin<MutableList<T>> selectAndRejectWith(List<T> list,
                                                                    Predicate2<? super T,? super IV> predicate,
                                                                    IV injectedValue)

partition

public static <T> PartitionMutableList<T> partition(List<T> list,
                                                    Predicate<? super T> predicate)

partitionWith

public static <T,P> PartitionMutableList<T> partitionWith(List<T> list,
                                                                Predicate2<? super T,? super P> predicate,
                                                                P parameter)

removeIf

public static <T> boolean removeIf(List<T> list,
                                   Predicate<? super T> predicate)

removeIfWith

public static <T,P> boolean removeIfWith(List<T> list,
                                               Predicate2<? super T,? super P> predicate,
                                               P parameter)

removeIf

public static <T> boolean removeIf(List<T> list,
                                   Predicate<? super T> predicate,
                                   Procedure<? super T> procedure)

removeIfWith

public static <T,P> boolean removeIfWith(List<T> list,
                                               Predicate2<? super T,? super P> predicate,
                                               P parameter,
                                               Procedure<? super T> procedure)

detectIndex

public static <T> int detectIndex(List<T> list,
                                  Predicate<? super T> predicate)

Searches for the first occurrence where the predicate evaluates to true.

See Also:

Iterate.detectIndex(Iterable, Predicate)

detectIndexWith

public static <T,IV> int detectIndexWith(List<T> list,
                                               Predicate2<? super T,? super IV> predicate,
                                               IV injectedValue)

Searches for the first occurrence where the predicate evaluates to true.

See Also:

Iterate.detectIndexWith(Iterable, Predicate2, Object)

detectLastIndex

public static <T> int detectLastIndex(List<T> list,
                                      Predicate<? super T> predicate)

injectIntoWith

public static <T,IV,P> IV injectIntoWith(IV injectedValue,
                                                     List<T> list,
                                                     Function3<? super IV,? super T,? super P,? extends IV> function,
                                                     P parameter)

forEachWith

public static <T,P> void forEachWith(List<T> list,
                                           Procedure2<? super T,? super P> procedure,
                                           P parameter)

collectWith

public static <T,P,A,R extends Collection<A>> R collectWith(List<T> list,
                                                                              Function2<? super T,? super P,? extends A> function,
                                                                              P parameter,
                                                                              R targetCollection)

distinct

@Deprecated
public static <T,R extends List<T>> R distinct(List<T> list,
                                                     R targetList)

Deprecated.

in 7.0.

distinct

public static <T> MutableList<T> distinct(List<T> list)

Since:

7.0.

distinct

public static <T> MutableList<T> distinct(List<T> list,
                                          HashingStrategy<? super T> hashingStrategy)

Since:

7.0.

take

public static <T> MutableList<T> take(List<T> list,
                                      int count)

See Also:

Iterate.take(Iterable, int)

take

public static <T,R extends Collection<T>> R take(List<T> list,
                                                       int count,
                                                       R targetList)

See Also:

Iterate.take(Iterable, int)

drop

public static <T> MutableList<T> drop(List<T> list,
                                      int count)

See Also:

Iterate.drop(Iterable, int)

drop

public static <T,R extends Collection<T>> R drop(List<T> list,
                                                       int count,
                                                       R targetList)

See Also:

Iterate.drop(Iterable, int)

appendString

public static <T> void appendString(List<T> list,
                                    Appendable appendable,
                                    String start,
                                    String separator,
                                    String end)

See Also:

RichIterable.appendString(Appendable, String, String, String)

groupBy

public static <T,V> FastListMultimap<V,T> groupBy(List<T> list,
                                                              Function<? super T,? extends V> function)

See Also:

Iterate.groupBy(Iterable, Function)

groupBy

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

See Also:

Iterate.groupBy(Iterable, Function, MutableMultimap)

groupByEach

public static <T,V> FastListMultimap<V,T> groupByEach(List<T> list,
                                                                  Function<? super T,? extends Iterable<V>> function)

groupByEach

public static <T,V,R extends MutableMultimap<V,T>> R groupByEach(List<T> list,
                                                                                   Function<? super T,? extends Iterable<V>> function,
                                                                                   R target)

groupByUniqueKey

public static <K,T> MutableMap<K,T> groupByUniqueKey(List<T> list,
                                                                 Function<? super T,? extends K> function)

groupByUniqueKey

public static <K,T,R extends MutableMapIterable<K,T>> R groupByUniqueKey(List<T> list,
                                                                                           Function<? super T,? extends K> function,
                                                                                           R target)

minBy

public static <T,V extends Comparable<? super V>> T minBy(List<T> list,
                                                                Function<? super T,? extends V> function)

maxBy

public static <T,V extends Comparable<? super V>> T maxBy(List<T> list,
                                                                Function<? super T,? extends V> function)

min

public static <T> T min(List<T> list,
                        Comparator<? super T> comparator)

max

public static <T> T max(List<T> list,
                        Comparator<? super T> comparator)

min

public static <T> T min(List<T> list)

max

public static <T> T max(List<T> list)

zip

public static <X,Y> MutableList<Pair<X,Y>> zip(List<X> list,
                                                           Iterable<Y> iterable)

zip

public static <X,Y,R extends Collection<Pair<X,Y>>> R zip(List<X> list,
                                                                            Iterable<Y> iterable,
                                                                            R target)

zipWithIndex

public static <T> MutableList<Pair<T,Integer>> zipWithIndex(List<T> list)

zipWithIndex

public static <T,R extends Collection<Pair<T,Integer>>> R zipWithIndex(List<T> list,
                                                                                   R target)

aggregateInPlaceBy

public static <T,K,V> MutableMap<K,V> aggregateInPlaceBy(List<T> list,
                                                                           Function<? super T,? extends K> groupBy,
                                                                           Function0<? extends V> zeroValueFactory,
                                                                           Procedure2<? super V,? super T> mutatingAggregator)

aggregateBy

public static <T,K,V> MutableMap<K,V> aggregateBy(List<T> list,
                                                                    Function<? super T,? extends K> groupBy,
                                                                    Function0<? extends V> zeroValueFactory,
                                                                    Function2<? super V,? super T,? extends V> nonMutatingAggregator)

takeWhile

public static <T> MutableList<T> takeWhile(List<T> list,
                                           Predicate<? super T> predicate)

dropWhile

public static <T> MutableList<T> dropWhile(List<T> list,
                                           Predicate<? super T> predicate)

partitionWhile

public static <T> PartitionMutableList<T> partitionWhile(List<T> list,
                                                         Predicate<? super T> predicate)

sumByInt

public static <V,T> ObjectLongMap<V> sumByInt(List<T> list,
                                                    Function<? super T,? extends V> groupBy,
                                                    IntFunction<? super T> function)

sumByLong

public static <V,T> ObjectLongMap<V> sumByLong(List<T> list,
                                                     Function<? super T,? extends V> groupBy,
                                                     LongFunction<? super T> function)

sumByFloat

public static <V,T> ObjectDoubleMap<V> sumByFloat(List<T> list,
                                                        Function<? super T,? extends V> groupBy,
                                                        FloatFunction<? super T> function)

sumByDouble

public static <V,T> ObjectDoubleMap<V> sumByDouble(List<T> list,
                                                         Function<? super T,? extends V> groupBy,
                                                         DoubleFunction<? super T> function)