org.eclipse.collections.impl.utility.ListIterate

public final class ListIterate
extends Object

The ListIterate utility class can be useful for iterating over lists, especially if there is a desire to return a MutableList from any of the iteration methods.

Since:: 1.0

Method Summary

Modifier and Type	Method	Description
`static <T> boolean`	`allSatisfy(List<T> list, Predicate<? super T> predicate)`
`static <T, IV> boolean`	`allSatisfyWith(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)`
`static <T> boolean`	`anySatisfy(List<T> list, Predicate<? super T> predicate)`
`static <T, IV> boolean`	`anySatisfyWith(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)`
`static <T> void`	`appendString(List<T> list, Appendable appendable, String start, String separator, String end)`
`static <T> RichIterable<RichIterable<T>>`	`chunk(List<T> list, int size)`
`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> MutableList<A>`	`collectWith(List<T> list, Function2<? super T,? super P,? extends A> function, P parameter)`
`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> 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> T`	`detectIfNone(List<T> list, Predicate<? super T> predicate, T ifNone)`
`static <T> int`	`detectIndex(List<T> list, Predicate<? super T> predicate)`	Searches for the first index where the predicate evaluates to true.
`static <T, P> int`	`detectIndexWith(List<T> list, Predicate2<? super T,? super P> predicate, P parameter)`	Searches for the first index where the predicate2 and parameter evaluates to true.
`static <T> int`	`detectLastIndex(List<T> list, Predicate<? super T> predicate)`	Returns the last index where the predicate evaluates to true.
`static <T> Optional<T>`	`detectOptional(List<T> list, Predicate<? super T> predicate)`
`static <T, IV> T`	`detectWith(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)`
`static <T, IV> T`	`detectWithIfNone(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue, T ifNone)`
`static <T, IV> Optional<T>`	`detectWithOptional(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)`
`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, V> MutableList<T>`	`distinctBy(List<T> list, Function<? super T,? extends V> function)`
`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 boolean`	`equals(List<?> one, List<?> two)`
`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)`	Iterates over both lists together, evaluating Procedure2 with the current element from each list.
`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)`
`static <T> T`	`getFirst(List<T> collection)`	Returns the first element of a list.
`static <T> T`	`getLast(List<T> list)`	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 injectedValue)`
`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 void`	`rangeCheck(int from, int to, int size)`
`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> void`	`reverseForEach(List<T> list, Procedure<? super T> procedure)`	Iterates over the List in reverse order executing the Procedure for each element
`static <T> void`	`reverseForEachWithIndex(List<T> list, ObjectIntProcedure<? super T> objectIntProcedure)`	Iterates over the List in reverse order executing the Procedure for each element.
`static <T> List<T>`	`reverseThis(List<T> list)`	Reverses the order of the items in the list.
`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, S> MutableList<S>`	`selectInstancesOf(List<T> list, Class<S> 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 <V, T> MutableMap<V,BigDecimal>`	`sumByBigDecimal(List<T> list, Function<T,V> groupBy, Function<? super T,BigDecimal> function)`
`static <V, T> MutableMap<V,BigInteger>`	`sumByBigInteger(List<T> list, Function<T,V> groupBy, Function<? super T,BigInteger> function)`
`static <V, T> ObjectDoubleMap<V>`	`sumByDouble(List<T> list, Function<T,V> groupBy, DoubleFunction<? super T> function)`
`static <V, T> ObjectDoubleMap<V>`	`sumByFloat(List<T> list, Function<T,V> groupBy, FloatFunction<? super T> function)`
`static <V, T> ObjectLongMap<V>`	`sumByInt(List<T> list, Function<T,V> groupBy, IntFunction<? super T> function)`
`static <V, T> ObjectLongMap<V>`	`sumByLong(List<T> list, Function<T,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 Details
- equals
  
  public static boolean equals(List<?> one, List<?> two)
- 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, S> MutableList<S> selectInstancesOf(List<T> list, Class<S> 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)
  
  See Also:
  
  Iterate.countWith(Iterable, Predicate2, Object)
- 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, MutableBooleanCollection)
- 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, MutableByteCollection)
- 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, MutableCharCollection)
- 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, MutableDoubleCollection)
- 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, MutableFloatCollection)
- 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, MutableIntCollection)
- 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, MutableLongCollection)
- 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, MutableShortCollection)
- 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)
- getFirst
  
  public static <T> T getFirst(List<T> collection)
  
  Returns the first element of a list.
- getLast
  
  public static <T> T getLast(List<T> list)
  
  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)
- reverseForEach
  
  public static <T> void reverseForEach(List<T> list, Procedure<? super T> procedure)
  
  Iterates over the List in reverse order executing the Procedure for each element
- reverseForEachWithIndex
  
  public static <T> void reverseForEachWithIndex(List<T> list, ObjectIntProcedure<? super T> objectIntProcedure)
  
  Iterates over the List in reverse order executing the Procedure for each element. The index passed into the ObjectIntProcedure is the actual index of the range.
- 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.
- rangeCheck
  
  public static void rangeCheck(int from, int to, int size)
- forEachInBoth
  
  public static <T1, T2> void forEachInBoth(List<T1> list1, List<T2> list2, Procedure2<? super T1,? super T2> procedure)
  
  Iterates over both lists together, evaluating Procedure2 with the current element from each list.
- forEachWithIndex
  
  public static <T> void forEachWithIndex(List<T> list, ObjectIntProcedure<? super T> objectIntProcedure)
  
  See Also:
  
  Iterate.forEachWithIndex(Iterable, ObjectIntProcedure)
- detect
  
  public static <T> T detect(List<T> list, Predicate<? super T> predicate)
  
  See Also:
  
  Iterate.detect(Iterable, Predicate)
- detectWith
  
  public static <T, IV> T detectWith(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)
  
  See Also:
  
  Iterate.detectWith(Iterable, Predicate2, Object)
- detectOptional
  
  public static <T> Optional<T> detectOptional(List<T> list, Predicate<? super T> predicate)
  
  See Also:
  
  Iterate.detectOptional(Iterable, Predicate)
- detectWithOptional
  
  public static <T, IV> Optional<T> detectWithOptional(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)
  
  See Also:
  
  Iterate.detectWithOptional(Iterable, Predicate2, Object)
- detectIfNone
  
  public static <T> T detectIfNone(List<T> list, Predicate<? super T> predicate, T ifNone)
  
  See Also:
  
  Iterate.detectIfNone(Iterable, Predicate, Object)
- detectWithIfNone
  
  public static <T, IV> T detectWithIfNone(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue, T ifNone)
  
  See Also:
  
  Iterate.detectWithIfNone(Iterable, Predicate2, Object, Object)
- injectInto
  
  public static <T, IV> IV injectInto(IV injectValue, List<T> list, Function2<? super IV,? super T,? extends IV> function)
  
  See Also:
  
  Iterate.injectInto(Object, Iterable, Function2)
- injectInto
  
  public static <T> int injectInto(int injectValue, List<T> list, IntObjectToIntFunction<? super T> function)
  
  See Also:
  
  Iterate.injectInto(int, Iterable, IntObjectToIntFunction)
- injectInto
  
  public static <T> long injectInto(long injectValue, List<T> list, LongObjectToLongFunction<? super T> function)
  
  See Also:
  
  Iterate.injectInto(long, Iterable, LongObjectToLongFunction)
- injectInto
  
  public static <T> double injectInto(double injectValue, List<T> list, DoubleObjectToDoubleFunction<? super T> function)
  
  See Also:
  
  Iterate.injectInto(double, Iterable, DoubleObjectToDoubleFunction)
- injectInto
  
  public static <T> float injectInto(float injectValue, List<T> list, FloatObjectToFloatFunction<? super T> function)
  
  See Also:
  
  Iterate.injectInto(float, Iterable, FloatObjectToFloatFunction)
- 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<T,V> groupBy, Function<? super T,BigDecimal> function)
- sumByBigInteger
  
  public static <V, T> MutableMap<V,BigInteger> sumByBigInteger(List<T> list, Function<T,V> groupBy, Function<? super T,BigInteger> function)
- sumByInt
  
  public static <V, T> ObjectLongMap<V> sumByInt(List<T> list, Function<T,V> groupBy, IntFunction<? super T> function)
- sumByLong
  
  public static <V, T> ObjectLongMap<V> sumByLong(List<T> list, Function<T,V> groupBy, LongFunction<? super T> function)
- sumByFloat
  
  public static <V, T> ObjectDoubleMap<V> sumByFloat(List<T> list, Function<T,V> groupBy, FloatFunction<? super T> function)
- sumByDouble
  
  public static <V, T> ObjectDoubleMap<V> sumByDouble(List<T> list, Function<T,V> groupBy, DoubleFunction<? super T> function)
- anySatisfy
  
  public static <T> boolean anySatisfy(List<T> list, Predicate<? super T> predicate)
  
  See Also:
  
  Iterate.anySatisfy(Iterable, Predicate)
- anySatisfyWith
  
  public static <T, IV> boolean anySatisfyWith(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)
  
  See Also:
  
  Iterate.anySatisfyWith(Iterable, Predicate2, Object)
- allSatisfy
  
  public static <T> boolean allSatisfy(List<T> list, Predicate<? super T> predicate)
  
  See Also:
  
  Iterate.allSatisfy(Iterable, Predicate)
- allSatisfyWith
  
  public static <T, IV> boolean allSatisfyWith(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)
  
  See Also:
  
  Iterate.allSatisfyWith(Iterable, Predicate2, Object)
- noneSatisfy
  
  public static <T> boolean noneSatisfy(List<T> list, Predicate<? super T> predicate)
  
  See Also:
  
  Iterate.noneSatisfy(Iterable, Predicate)
- noneSatisfyWith
  
  public static <T, P> boolean noneSatisfyWith(List<T> list, Predicate2<? super T,? super P> predicate, P injectedValue)
  
  See Also:
  
  Iterate.noneSatisfyWith(Iterable, Predicate2, Object)
- selectAndRejectWith
  
  public static <T, IV> Twin<MutableList<T>> selectAndRejectWith(List<T> list, Predicate2<? super T,? super IV> predicate, IV injectedValue)
  
  See Also:
  
  Iterate.selectAndRejectWith(Iterable, Predicate2, Object)
- partition
  
  public static <T> PartitionMutableList<T> partition(List<T> list, Predicate<? super T> predicate)
  
  See Also:
  
  Iterate.partition(Iterable, 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)
  
  See Also:
  
  Iterate.removeIf(Iterable, Predicate)
- removeIfWith
  
  public static <T, P> boolean removeIfWith(List<T> list, Predicate2<? super T,? super P> predicate, P parameter)
  
  See Also:
  
  Iterate.removeIfWith(Iterable, Predicate2, Object)
- 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 index where the predicate evaluates to true.
- detectIndexWith
  
  public static <T, P> int detectIndexWith(List<T> list, Predicate2<? super T,? super P> predicate, P parameter)
  
  Searches for the first index where the predicate2 and parameter evaluates to true.
- detectLastIndex
  
  public static <T> int detectLastIndex(List<T> list, Predicate<? super T> predicate)
  
  Returns the last index where the predicate evaluates to true. Returns -1 for no matches.
- 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)
  
  See Also:
  
  Iterate.forEachWith(Iterable, Procedure2, Object)
- collectWith
  
  public static <T, P, A> MutableList<A> collectWith(List<T> list, Function2<? super T,? super P,? extends A> function, P parameter)
  
  See Also:
  
  Iterate.collectWith(Iterable, Function2, Object)
- 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)
  
  See Also:
  
  Iterate.collectWith(Iterable, Function2, Object, Collection)
- 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.
- distinctBy
  
  public static <T, V> MutableList<T> distinctBy(List<T> list, Function<? super T,? extends V> function)
  
  Since:
  
  9.0
- reverseThis
  
  public static <T> List<T> reverseThis(List<T> list)
  Reverses the order of the items in the list.
  List<Integer> integers = Lists.fixedSize.of(1, 3, 2); Verify.assertListsEqual(FastList.newListWith(2, 3, 1), ListIterate.reverse(integers));
  Returns:
  
  the reversed list
- 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)
  
  See Also:
  
  Iterate.groupByEach(Iterable, 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)
  
  See Also:
  
  Iterate.groupByEach(Iterable, Function, MutableMultimap)
- groupByUniqueKey
  
  public static <K, T> MutableMap<K,T> groupByUniqueKey(List<T> list, Function<? super T,? extends K> function)
  
  See Also:
  
  Iterate.groupByUniqueKey(Iterable, Function)
- groupByUniqueKey
  
  public static <K, T, R extends MutableMapIterable<K, T>> R groupByUniqueKey(List<T> list, Function<? super T,? extends K> function, R target)
  
  See Also:
  
  Iterate.groupByUniqueKey(Iterable, Function, MutableMapIterable)
- min
  
  public static <T> T min(List<T> list, Comparator<? super T> comparator)
  
  See Also:
  
  Iterate.min(Iterable, Comparator)
- 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)
- max
  
  public static <T> T max(List<T> list, Comparator<? super T> comparator)
  
  See Also:
  
  Iterate.max(Iterable, Comparator)
- min
  
  public static <T> T min(List<T> list)
  
  See Also:
  
  Iterate.min(Iterable)
- max
  
  public static <T> T max(List<T> list)
  
  See Also:
  
  Iterate.max(Iterable)
- chunk
  
  public static <T> RichIterable<RichIterable<T>> chunk(List<T> list, int size)
  
  See Also:
  
  Iterate.chunk(Iterable, int)
- zip
  
  public static <X, Y> MutableList<Pair<X,Y>> zip(List<X> list, Iterable<Y> iterable)
  
  See Also:
  
  Iterate.zip(Iterable, Iterable)
- zip
  
  public static <X, Y, R extends Collection<Pair<X, Y>>> R zip(List<X> list, Iterable<Y> iterable, R target)
  
  See Also:
  
  Iterate.zip(Iterable, Iterable, Collection)
- zipWithIndex
  
  public static <T> MutableList<Pair<T,Integer>> zipWithIndex(List<T> list)
  
  See Also:
  
  Iterate.zipWithIndex(Iterable)
- zipWithIndex
  
  public static <T, R extends Collection<Pair<T, Integer>>> R zipWithIndex(List<T> list, R target)
  
  See Also:
  
  Iterate.zipWithIndex(Iterable, Collection)
- takeWhile
  
  public static <T> MutableList<T> takeWhile(List<T> list, Predicate<? super T> predicate)
  
  See Also:
  
  ListIterable.takeWhile(Predicate)
- dropWhile
  
  public static <T> MutableList<T> dropWhile(List<T> list, Predicate<? super T> predicate)
  
  See Also:
  
  ListIterable.dropWhile(Predicate)
- partitionWhile
  
  public static <T> PartitionMutableList<T> partitionWhile(List<T> list, Predicate<? super T> predicate)
  
  See Also:
  
  ListIterable.partitionWhile(Predicate)

Class ListIterate

Method Summary

Methods inherited from class java.lang.Object

Method Details