java.lang.Object
- org.eclipse.collections.impl.utility.ArrayIterate

```
public final class ArrayIterate
extends Object
```
This utility class provides iteration pattern implementations that work with Java arrays.

Since:

1.0

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`static <T,R extends Collection<T>> R`	`addAllTo(T[] objectArray, R targetCollection)`
`static <T> boolean`	`allSatisfy(T[] objectArray, Predicate<? super T> predicate)`
`static <T,P> boolean`	`allSatisfyWith(T[] objectArray, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T> boolean`	`anySatisfy(T[] objectArray, Predicate<? super T> predicate)`
`static <T,P> boolean`	`anySatisfyWith(T[] objectArray, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T> void`	`appendString(T[] array, Appendable appendable)`
`static <T> void`	`appendString(T[] array, Appendable appendable, String separator)`
`static <T> void`	`appendString(T[] array, Appendable appendable, String start, String separator, String end)`
`static <T> RichIterable<RichIterable<T>>`	`chunk(T[] array, int size)`
`static <T,V> MutableList<V>`	`collect(T[] objectArray, Function<? super T,? extends V> function)`
`static <T,V,R extends Collection<V>> R`	`collect(T[] objectArray, Function<? super T,? extends V> function, R targetCollection)`
`static <T> MutableBooleanList`	`collectBoolean(T[] objectArray, BooleanFunction<? super T> booleanFunction)`
`static <T,R extends MutableBooleanCollection> R`	`collectBoolean(T[] objectArray, BooleanFunction<? super T> booleanFunction, R target)`
`static <T> MutableByteList`	`collectByte(T[] objectArray, ByteFunction<? super T> byteFunction)`
`static <T,R extends MutableByteCollection> R`	`collectByte(T[] objectArray, ByteFunction<? super T> byteFunction, R target)`
`static <T> MutableCharList`	`collectChar(T[] objectArray, CharFunction<? super T> charFunction)`
`static <T,R extends MutableCharCollection> R`	`collectChar(T[] objectArray, CharFunction<? super T> charFunction, R target)`
`static <T> MutableDoubleList`	`collectDouble(T[] objectArray, DoubleFunction<? super T> doubleFunction)`
`static <T,R extends MutableDoubleCollection> R`	`collectDouble(T[] objectArray, DoubleFunction<? super T> doubleFunction, R target)`
`static <T> MutableFloatList`	`collectFloat(T[] objectArray, FloatFunction<? super T> floatFunction)`
`static <T,R extends MutableFloatCollection> R`	`collectFloat(T[] objectArray, FloatFunction<? super T> floatFunction, R target)`
`static <T,V> MutableList<V>`	`collectIf(T[] objectArray, Predicate<? super T> predicate, Function<? super T,? extends V> function)`
`static <T,V,R extends Collection<V>> R`	`collectIf(T[] objectArray, Predicate<? super T> predicate, Function<? super T,? extends V> function, R targetCollection)`
`static <T> MutableIntList`	`collectInt(T[] objectArray, IntFunction<? super T> intFunction)`
`static <T,R extends MutableIntCollection> R`	`collectInt(T[] objectArray, IntFunction<? super T> intFunction, R target)`
`static <T> MutableLongList`	`collectLong(T[] objectArray, LongFunction<? super T> longFunction)`
`static <T,R extends MutableLongCollection> R`	`collectLong(T[] objectArray, LongFunction<? super T> longFunction, R target)`
`static <T> MutableShortList`	`collectShort(T[] objectArray, ShortFunction<? super T> shortFunction)`
`static <T,R extends MutableShortCollection> R`	`collectShort(T[] objectArray, ShortFunction<? super T> shortFunction, R target)`
`static <T,P,V> MutableList<V>`	`collectWith(T[] objectArray, Function2<? super T,? super P,? extends V> function, P parameter)`
`static <T,P,V,R extends Collection<V>> R`	`collectWith(T[] objectArray, Function2<? super T,? super P,? extends V> function, P parameter, R targetCollection)`
`static boolean`	`contains(double[] doubleArray, double value)`	Returns `true` if the specified double array contains the specified double element.
`static boolean`	`contains(int[] intArray, int value)`	Returns `true` if the specified int array contains the specified int element.
`static boolean`	`contains(long[] longArray, long value)`	Returns `true` if the specified long array contains the specified long element.
`static <T> boolean`	`contains(T[] objectArray, T value)`	Returns `true` if the specified array contains the specified element.
`static <T> int`	`count(T[] objectArray, Predicate<? super T> predicate)`
`static <T,P> int`	`countWith(T[] objectArray, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T> T`	`detect(T[] objectArray, Predicate<? super T> predicate)`
`static <T> T`	`detectIfNone(T[] objectArray, Predicate<? super T> predicate, T ifNone)`
`static <T> int`	`detectIndex(T[] objectArray, Predicate<? super T> predicate)`	Returns the first index where the predicate evaluates to `true`.
`static <T,IV> int`	`detectIndexWith(T[] objectArray, Predicate2<? super T,? super IV> predicate, IV injectedValue)`	Searches for the first index where the predicate evaluates to `true`.
`static <T> int`	`detectLastIndex(T[] objectArray, Predicate<? super T> predicate)`	Returns the last index where the predicate evaluates to `true`.
`static <T> Optional<T>`	`detectOptional(T[] objectArray, Predicate<? super T> predicate)`
`static <T,P> T`	`detectWith(T[] objectArray, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T,P> T`	`detectWithIfNone(T[] objectArray, Predicate2<? super T,? super P> predicate, P parameter, T ifNone)`
`static <T,P> Optional<T>`	`detectWithOptional(T[] objectArray, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T> MutableList<T>`	`distinct(T[] objectArray)`
`static <T> MutableList<T>`	`distinct(T[] objectArray, HashingStrategy<? super T> hashingStrategy)`
`static <T,R extends List<T>> R`	`distinct(T[] objectArray, R targetList)`	Deprecated. in 7.0.
`static <T> MutableList<T>`	`drop(T[] array, int count)`
`static <T,R extends Collection<T>> R`	`drop(T[] array, int count, R target)`
`static <T,V> MutableList<V>`	`flatCollect(T[] objectArray, Function<? super T,? extends Iterable<V>> function)`
`static <T,V,R extends Collection<V>> R`	`flatCollect(T[] objectArray, Function<? super T,? extends Iterable<V>> function, R targetCollection)`
`static <T> void`	`forEach(T[] objectArray, int from, int to, Procedure<? super T> procedure)`	Iterates over the section of the list covered by the specified inclusive indexes.
`static <T> void`	`forEach(T[] objectArray, Procedure<? super T> procedure)`
`static <T1,T2> void`	`forEachInBoth(T1[] objectArray1, T2[] objectArray2, Procedure2<? super T1,? super T2> procedure)`
`static <T,P> void`	`forEachWith(T[] objectArray, Procedure2<? super T,? super P> procedure, P parameter)`
`static <T> void`	`forEachWithIndex(T[] objectArray, int from, int to, ObjectIntProcedure<? super T> objectIntProcedure)`	Iterates over the section of the list covered by the specified inclusive indexes.
`static <T> void`	`forEachWithIndex(T[] objectArray, ObjectIntProcedure<? super T> objectIntProcedure)`
`static <T> T`	`getFirst(T[] objectArray)`	Returns the first element of an array.
`static <T> T`	`getLast(T[] objectArray)`	Returns the last element of an Array.
`static <T,V> FastListMultimap<V,T>`	`groupBy(T[] array, Function<? super T,? extends V> function)`
`static <T,V,R extends MutableMultimap<V,T>> R`	`groupBy(T[] array, Function<? super T,? extends V> function, R target)`
`static <T,V> FastListMultimap<V,T>`	`groupByEach(T[] array, Function<? super T,? extends Iterable<V>> function)`
`static <T,V,R extends MutableMultimap<V,T>> R`	`groupByEach(T[] array, Function<? super T,? extends Iterable<V>> function, R target)`
`static <T,V> MutableMapIterable<V,T>`	`groupByUniqueKey(T[] array, Function<? super T,? extends V> function)`
`static <T,V,R extends MutableMapIterable<V,T>> R`	`groupByUniqueKey(T[] array, Function<? super T,? extends V> function, R target)`
`static <T> int`	`indexOf(T[] objectArray, T elem)`	Searches for the first occurrence of the given argument, testing for equality using the `equals` method.
`static <T> double`	`injectInto(double injectValue, T[] objectArray, DoubleObjectToDoubleFunction<? super T> function)`
`static <T> float`	`injectInto(float injectValue, T[] objectArray, FloatObjectToFloatFunction<? super T> function)`
`static <T> int`	`injectInto(int injectValue, T[] objectArray, IntObjectToIntFunction<? super T> function)`
`static <T> long`	`injectInto(long injectValue, T[] objectArray, LongObjectToLongFunction<? super T> function)`
`static <T,IV> IV`	`injectInto(IV injectValue, T[] objectArray, Function2<? super IV,? super T,? extends IV> function)`
`static <T,IV,P> IV`	`injectIntoWith(IV injectValue, T[] objectArray, Function3<? super IV,? super T,? super P,? extends IV> function, P parameter)`
`static boolean`	`isEmpty(Object[] array)`	A null safe form of isEmpty.
`static <T> String`	`makeString(T... array)`
`static <T> String`	`makeString(T[] array, String separator)`
`static <T> String`	`makeString(T[] array, String start, String separator, String end)`
`static <T> T`	`max(T... array)`
`static <T> T`	`max(T[] array, Comparator<? super T> comparator)`
`static <T,V extends Comparable<? super V>> T`	`maxBy(T[] array, Function<? super T,? extends V> function)`
`static <T> T`	`min(T... array)`
`static <T> T`	`min(T[] array, Comparator<? super T> comparator)`
`static <T,V extends Comparable<? super V>> T`	`minBy(T[] array, Function<? super T,? extends V> function)`
`static <T> boolean`	`noneSatisfy(T[] objectArray, Predicate<? super T> predicate)`
`static <T,P> boolean`	`noneSatisfyWith(T[] objectArray, Predicate2<? super T,? super P> predicate, P parameter)`
`static boolean`	`notEmpty(Object[] array)`	A null safe form of notEmpty.
`static <T> PartitionFastList<T>`	`partition(T[] array, Predicate<? super T> predicate)`
`static <T,P> PartitionFastList<T>`	`partitionWith(T[] array, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T> MutableList<T>`	`reject(T[] objectArray, Predicate<? super T> predicate)`
`static <T,R extends Collection<T>> R`	`reject(T[] objectArray, Predicate<? super T> predicate, R targetCollection)`
`static <T,P,R extends Collection<T>> R`	`rejectWith(T[] objectArray, Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)`
`static <T,P> MutableList<T>`	`rejectWith(T[] objectArray, Predicate2<? super T,P> predicate, P parameter)`
`static <T> void`	`reverse(T[] array, int size)`
`static <T> MutableList<T>`	`select(T[] objectArray, Predicate<? super T> predicate)`
`static <T,R extends Collection<T>> R`	`select(T[] objectArray, Predicate<? super T> predicate, R targetCollection)`
`static <T,P> Twin<MutableList<T>>`	`selectAndRejectWith(T[] objectArray, Predicate2<? super T,? super P> predicate, P parameter)`	Deprecated. since 6.0 use `RichIterable.partitionWith(Predicate2, Object)` instead.
`static <T> FastList<T>`	`selectInstancesOf(Object[] objectArray, Class<T> clazz)`
`static <T,P,R extends Collection<T>> R`	`selectWith(T[] objectArray, Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)`
`static <T,P> MutableList<T>`	`selectWith(T[] objectArray, Predicate2<? super T,P> predicate, P parameter)`
`static int`	`size(Object[] array)`	Return the size of the array.
`static <T> void`	`sort(T[] array, int size, Comparator<? super T> comparator)`	Deprecated. in 7.0.
`static <V,T> MutableMap<V,BigDecimal>`	`sumByBigDecimal(T[] array, Function<? super T,? extends V> groupBy, Function<? super T,BigDecimal> function)`
`static <V,T> MutableMap<V,BigInteger>`	`sumByBigInteger(T[] array, Function<? super T,? extends V> groupBy, Function<? super T,BigInteger> function)`
`static <V,T> ObjectDoubleMap<V>`	`sumByDouble(T[] array, Function<? super T,? extends V> groupBy, DoubleFunction<? super T> function)`
`static <V,T> ObjectDoubleMap<V>`	`sumByFloat(T[] array, Function<? super T,? extends V> groupBy, FloatFunction<? super T> function)`
`static <V,T> ObjectLongMap<V>`	`sumByInt(T[] array, Function<? super T,? extends V> groupBy, IntFunction<? super T> function)`
`static <V,T> ObjectLongMap<V>`	`sumByLong(T[] array, Function<? super T,? extends V> groupBy, LongFunction<? super T> function)`
`static <T> BigDecimal`	`sumOfBigDecimal(T[] array, Function<? super T,BigDecimal> function)`
`static <T> BigInteger`	`sumOfBigInteger(T[] array, Function<? super T,BigInteger> function)`
`static <T> double`	`sumOfDouble(T[] array, DoubleFunction<? super T> function)`
`static <T> double`	`sumOfFloat(T[] array, FloatFunction<? super T> function)`
`static <T> long`	`sumOfInt(T[] array, IntFunction<? super T> function)`
`static <T> long`	`sumOfLong(T[] array, LongFunction<? super T> function)`
`static <T> MutableList<T>`	`take(T[] array, int count)`
`static <T,R extends Collection<T>> R`	`take(T[] array, int count, R target)`
`static <T,K,V> MutableMap<K,V>`	`toMap(T[] objectArray, Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)`	Iterate over the specified array applying the specified Functions to each element to calculate a key and value, and return the results as a Map.
`static <K,V> MutableMap<K,V>`	`toMap(V[] objectArray, Function<? super V,? extends K> keyFunction)`	Iterate over the specified array applying the specified Function to each element to calculate a key and return the results as a HashMap.
`static <X,Y> MutableList<Pair<X,Y>>`	`zip(X[] xs, Y[] ys)`
`static <X,Y,R extends Collection<Pair<X,Y>>> R`	`zip(X[] xs, Y[] ys, R targetCollection)`
`static <T> MutableList<Pair<T,Integer>>`	`zipWithIndex(T... array)`
`static <T,R extends Collection<Pair<T,Integer>>> R`	`zipWithIndex(T[] array, R targetCollection)`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

reverse

public static <T> void reverse(T[] array,
                               int size)

sort
```
@Deprecated
public static <T> void sort(T[] array,
                            int size,
                            Comparator<? super T> comparator)
```
Deprecated.
in 7.0. Use Arrays.sort(Object[], int, int) or Arrays.sort(Object[], int, int, Comparator) instead.

Inline calls to appropriate Arrays.sort() method which now uses TimSort by default since Java 8.

minBy

public static <T,V extends Comparable<? super V>> T minBy(T[] array,
                                                                Function<? super T,? extends V> function)

maxBy

public static <T,V extends Comparable<? super V>> T maxBy(T[] array,
                                                                Function<? super T,? extends V> function)

min

public static <T> T min(T[] array,
                        Comparator<? super T> comparator)

See Also:: Iterate.min(Iterable, Comparator)

max

public static <T> T max(T[] array,
                        Comparator<? super T> comparator)

See Also:: Iterate.max(Iterable, Comparator)

min

public static <T> T min(T... array)

See Also:: Iterate.min(Iterable)

max

public static <T> T max(T... array)

See Also:: Iterate.max(Iterable)

select

public static <T> MutableList<T> select(T[] objectArray,
                                        Predicate<? super T> predicate)

See Also:: Iterate.select(Iterable, Predicate)

selectWith

public static <T,P> MutableList<T> selectWith(T[] objectArray,
                                                    Predicate2<? super T,P> predicate,
                                                    P parameter)

See Also:: Iterate.selectWith(Iterable, Predicate2, Object)

selectInstancesOf

public static <T> FastList<T> selectInstancesOf(Object[] objectArray,
                                                Class<T> clazz)

See Also:: Iterate.selectInstancesOf(Iterable, Class)

count

public static <T> int count(T[] objectArray,
                            Predicate<? super T> predicate)

See Also:: Iterate.count(Iterable, Predicate)

countWith

public static <T,P> int countWith(T[] objectArray,
                                        Predicate2<? super T,? super P> predicate,
                                        P parameter)

See Also:: Iterate.countWith(Iterable, Predicate2, Object)

selectAndRejectWith

@Deprecated
public static <T,P> Twin<MutableList<T>> selectAndRejectWith(T[] objectArray,
                                                                   Predicate2<? super T,? super P> predicate,
                                                                   P parameter)

Deprecated.

since 6.0 use RichIterable.partitionWith(Predicate2, Object) instead.

See Also:: Iterate.selectAndRejectWith(Iterable, Predicate2, Object)

partition

public static <T> PartitionFastList<T> partition(T[] array,
                                                 Predicate<? super T> predicate)

See Also:: Iterate.partition(Iterable, Predicate)

partitionWith

public static <T,P> PartitionFastList<T> partitionWith(T[] array,
                                                             Predicate2<? super T,? super P> predicate,
                                                             P parameter)

collectIf

public static <T,V> MutableList<V> collectIf(T[] objectArray,
                                                   Predicate<? super T> predicate,
                                                   Function<? super T,? extends V> function)

See Also:: Iterate.collectIf(Iterable, Predicate, Function)

select

public static <T,R extends Collection<T>> R select(T[] objectArray,
                                                         Predicate<? super T> predicate,
                                                         R targetCollection)

See Also:: Iterate.select(Iterable, Predicate, Collection)

selectWith

public static <T,P,R extends Collection<T>> R selectWith(T[] objectArray,
                                                                     Predicate2<? super T,? super P> predicate,
                                                                     P parameter,
                                                                     R targetCollection)

See Also:: Iterate.selectWith(Iterable, Predicate2, Object, Collection)

collectIf

public static <T,V,R extends Collection<V>> R collectIf(T[] objectArray,
                                                                    Predicate<? super T> predicate,
                                                                    Function<? super T,? extends V> function,
                                                                    R targetCollection)

See Also:: Iterate.collectIf(Iterable, Predicate, Function, Collection)

reject

public static <T> MutableList<T> reject(T[] objectArray,
                                        Predicate<? super T> predicate)

See Also:: Iterate.reject(Iterable, Predicate)

rejectWith

public static <T,P> MutableList<T> rejectWith(T[] objectArray,
                                                    Predicate2<? super T,P> predicate,
                                                    P parameter)

See Also:: Iterate.rejectWith(Iterable, Predicate2, Object)

reject

public static <T,R extends Collection<T>> R reject(T[] objectArray,
                                                         Predicate<? super T> predicate,
                                                         R targetCollection)

See Also:: Iterate.reject(Iterable, Predicate, Collection)

rejectWith

public static <T,P,R extends Collection<T>> R rejectWith(T[] objectArray,
                                                                     Predicate2<? super T,? super P> predicate,
                                                                     P parameter,
                                                                     R targetCollection)

See Also:: Iterate.rejectWith(Iterable, Predicate2, Object, Collection)

addAllTo

public static <T,R extends Collection<T>> R addAllTo(T[] objectArray,
                                                           R targetCollection)

See Also:: Iterate.addAllTo(Iterable, Collection)

collect

public static <T,V> MutableList<V> collect(T[] objectArray,
                                                 Function<? super T,? extends V> function)

See Also:: Iterate.collect(Iterable, Function)

collect

public static <T,V,R extends Collection<V>> R collect(T[] objectArray,
                                                                  Function<? super T,? extends V> function,
                                                                  R targetCollection)

See Also:: Iterate.collect(Iterable, Function, Collection)

collectBoolean

public static <T> MutableBooleanList collectBoolean(T[] objectArray,
                                                    BooleanFunction<? super T> booleanFunction)

See Also:: Iterate.collectBoolean(Iterable, BooleanFunction)

collectBoolean

public static <T,R extends MutableBooleanCollection> R collectBoolean(T[] objectArray,
                                                                            BooleanFunction<? super T> booleanFunction,
                                                                            R target)

See Also:: Iterate.collectBoolean(Iterable, BooleanFunction, MutableBooleanCollection)

collectByte

public static <T> MutableByteList collectByte(T[] objectArray,
                                              ByteFunction<? super T> byteFunction)

See Also:: Iterate.collectByte(Iterable, ByteFunction)

collectByte

public static <T,R extends MutableByteCollection> R collectByte(T[] objectArray,
                                                                      ByteFunction<? super T> byteFunction,
                                                                      R target)

See Also:: Iterate.collectByte(Iterable, ByteFunction, MutableByteCollection)

collectChar

public static <T> MutableCharList collectChar(T[] objectArray,
                                              CharFunction<? super T> charFunction)

See Also:: Iterate.collectChar(Iterable, CharFunction)

collectChar

public static <T,R extends MutableCharCollection> R collectChar(T[] objectArray,
                                                                      CharFunction<? super T> charFunction,
                                                                      R target)

See Also:: Iterate.collectChar(Iterable, CharFunction, MutableCharCollection)

collectDouble

public static <T> MutableDoubleList collectDouble(T[] objectArray,
                                                  DoubleFunction<? super T> doubleFunction)

See Also:: Iterate.collectDouble(Iterable, DoubleFunction)

collectDouble

public static <T,R extends MutableDoubleCollection> R collectDouble(T[] objectArray,
                                                                          DoubleFunction<? super T> doubleFunction,
                                                                          R target)

See Also:: Iterate.collectDouble(Iterable, DoubleFunction, MutableDoubleCollection)

collectFloat

public static <T> MutableFloatList collectFloat(T[] objectArray,
                                                FloatFunction<? super T> floatFunction)

See Also:: Iterate.collectFloat(Iterable, FloatFunction)

collectFloat

public static <T,R extends MutableFloatCollection> R collectFloat(T[] objectArray,
                                                                        FloatFunction<? super T> floatFunction,
                                                                        R target)

See Also:: Iterate.collectFloat(Iterable, FloatFunction, MutableFloatCollection)

collectInt

public static <T> MutableIntList collectInt(T[] objectArray,
                                            IntFunction<? super T> intFunction)

See Also:: Iterate.collectInt(Iterable, IntFunction)

collectInt

public static <T,R extends MutableIntCollection> R collectInt(T[] objectArray,
                                                                    IntFunction<? super T> intFunction,
                                                                    R target)

See Also:: Iterate.collectInt(Iterable, IntFunction, MutableIntCollection)

collectLong

public static <T> MutableLongList collectLong(T[] objectArray,
                                              LongFunction<? super T> longFunction)

See Also:: Iterate.collectLong(Iterable, LongFunction)

collectLong

public static <T,R extends MutableLongCollection> R collectLong(T[] objectArray,
                                                                      LongFunction<? super T> longFunction,
                                                                      R target)

See Also:: Iterate.collectLong(Iterable, LongFunction, MutableLongCollection)

collectShort

public static <T> MutableShortList collectShort(T[] objectArray,
                                                ShortFunction<? super T> shortFunction)

See Also:: Iterate.collectShort(Iterable, ShortFunction)

collectShort

public static <T,R extends MutableShortCollection> R collectShort(T[] objectArray,
                                                                        ShortFunction<? super T> shortFunction,
                                                                        R target)

See Also:: Iterate.collectShort(Iterable, ShortFunction, MutableShortCollection)

flatCollect

public static <T,V> MutableList<V> flatCollect(T[] objectArray,
                                                     Function<? super T,? extends Iterable<V>> function)

See Also:: Iterate.flatCollect(Iterable, Function)

flatCollect

public static <T,V,R extends Collection<V>> R flatCollect(T[] objectArray,
                                                                      Function<? super T,? extends Iterable<V>> function,
                                                                      R targetCollection)

getFirst
```
public static <T> T getFirst(T[] objectArray)
```
Returns the first element of an array. This method is null safe.

getLast
```
public static <T> T getLast(T[] objectArray)
```
Returns the last element of an Array. This method is null safe.

forEach

public static <T> void forEach(T[] objectArray,
                               Procedure<? super T> procedure)

See Also:: Iterate.forEach(Iterable, Procedure)

forEach

public static <T> void forEach(T[] objectArray,
                               int from,
                               int to,
                               Procedure<? super T> procedure)

Iterates over the section of the list covered by the specified inclusive indexes. The indexes are both inclusive.

forEachInBoth

public static <T1,T2> void forEachInBoth(T1[] objectArray1,
                                               T2[] objectArray2,
                                               Procedure2<? super T1,? super T2> procedure)

See Also:: ListIterate.forEachInBoth(List, List, Procedure2)

forEachWithIndex

public static <T> void forEachWithIndex(T[] objectArray,
                                        ObjectIntProcedure<? super T> objectIntProcedure)

See Also:: Iterate.forEachWithIndex(Iterable, ObjectIntProcedure)

forEachWithIndex

public static <T> void forEachWithIndex(T[] objectArray,
                                        int from,
                                        int to,
                                        ObjectIntProcedure<? super T> objectIntProcedure)

Iterates over the section of the list covered by the specified inclusive indexes. The indexes are both inclusive.

detect

public static <T> T detect(T[] objectArray,
                           Predicate<? super T> predicate)

See Also:: Iterate.detect(Iterable, Predicate)

detectWith

public static <T,P> T detectWith(T[] objectArray,
                                       Predicate2<? super T,? super P> predicate,
                                       P parameter)

See Also:: Iterate.detectWith(Iterable, Predicate2, Object)

detectOptional

public static <T> Optional<T> detectOptional(T[] objectArray,
                                             Predicate<? super T> predicate)

See Also:: Iterate.detectOptional(Iterable, Predicate)

detectWithOptional

public static <T,P> Optional<T> detectWithOptional(T[] objectArray,
                                                         Predicate2<? super T,? super P> predicate,
                                                         P parameter)

See Also:: Iterate.detectWithOptional(Iterable, Predicate2, Object)

detectIfNone

public static <T> T detectIfNone(T[] objectArray,
                                 Predicate<? super T> predicate,
                                 T ifNone)

See Also:: Iterate.detectIfNone(Iterable, Predicate, Object)

detectWithIfNone

public static <T,P> T detectWithIfNone(T[] objectArray,
                                             Predicate2<? super T,? super P> predicate,
                                             P parameter,
                                             T ifNone)

See Also:: Iterate.detectWithIfNone(Iterable, Predicate2, Object, Object)

injectInto

public static <T,IV> IV injectInto(IV injectValue,
                                         T[] objectArray,
                                         Function2<? super IV,? super T,? extends IV> function)

See Also:: Iterate.injectInto(Object, Iterable, Function2)

injectInto

public static <T> int injectInto(int injectValue,
                                 T[] objectArray,
                                 IntObjectToIntFunction<? super T> function)

See Also:: Iterate.injectInto(int, Iterable, IntObjectToIntFunction)

injectInto

public static <T> long injectInto(long injectValue,
                                  T[] objectArray,
                                  LongObjectToLongFunction<? super T> function)

See Also:: Iterate.injectInto(long, Iterable, LongObjectToLongFunction)

injectInto

public static <T> float injectInto(float injectValue,
                                   T[] objectArray,
                                   FloatObjectToFloatFunction<? super T> function)

Since:: 6.0
See Also:: Iterate.injectInto(float, Iterable, FloatObjectToFloatFunction)

injectInto

public static <T> double injectInto(double injectValue,
                                    T[] objectArray,
                                    DoubleObjectToDoubleFunction<? super T> function)

See Also:: Iterate.injectInto(double, Iterable, DoubleObjectToDoubleFunction)

distinct

@Deprecated
public static <T,R extends List<T>> R distinct(T[] objectArray,
                                                     R targetList)

Deprecated.

in 7.0.

distinct

public static <T> MutableList<T> distinct(T[] objectArray)

Since:: 7.0.

distinct

public static <T> MutableList<T> distinct(T[] objectArray,
                                          HashingStrategy<? super T> hashingStrategy)

Since:: 7.0.

contains

public static <T> boolean contains(T[] objectArray,
                                   T value)

Returns true if the specified array contains the specified element.

contains

public static boolean contains(int[] intArray,
                               int value)

Returns true if the specified int array contains the specified int element.

contains

public static boolean contains(double[] doubleArray,
                               double value)

Returns true if the specified double array contains the specified double element.

contains

public static boolean contains(long[] longArray,
                               long value)

Returns true if the specified long array contains the specified long element.

indexOf
```
public static <T> int indexOf(T[] objectArray,
                              T elem)
```
Searches for the first occurrence of the given argument, testing for equality using the equals method.

detectIndex

public static <T> int detectIndex(T[] objectArray,
                                  Predicate<? super T> predicate)

Returns the first index where the predicate evaluates to true. Returns -1 for no matches.

detectIndexWith

public static <T,IV> int detectIndexWith(T[] objectArray,
                                               Predicate2<? super T,? super IV> predicate,
                                               IV injectedValue)

Searches for the first index where the predicate evaluates to true. Returns -1 for no matches.

detectLastIndex

public static <T> int detectLastIndex(T[] objectArray,
                                      Predicate<? super T> predicate)

Returns the last index where the predicate evaluates to true. Returns -1 for no matches.

isEmpty
```
public static boolean isEmpty(Object[] array)
```
A null safe form of isEmpty. Null or length of zero returns true.

notEmpty
```
public static boolean notEmpty(Object[] array)
```
A null safe form of notEmpty. The opposite of isEmpty is returned.

size

public static int size(Object[] array)

Return the size of the array.

anySatisfy

public static <T> boolean anySatisfy(T[] objectArray,
                                     Predicate<? super T> predicate)

See Also:: Iterate.anySatisfy(Iterable, Predicate)

anySatisfyWith

public static <T,P> boolean anySatisfyWith(T[] objectArray,
                                                 Predicate2<? super T,? super P> predicate,
                                                 P parameter)

See Also:: Iterate.anySatisfyWith(Iterable, Predicate2, Object)

allSatisfy

public static <T> boolean allSatisfy(T[] objectArray,
                                     Predicate<? super T> predicate)

See Also:: Iterate.allSatisfy(Iterable, Predicate)

allSatisfyWith

public static <T,P> boolean allSatisfyWith(T[] objectArray,
                                                 Predicate2<? super T,? super P> predicate,
                                                 P parameter)

See Also:: Iterate.allSatisfyWith(Iterable, Predicate2, Object)

noneSatisfy

public static <T> boolean noneSatisfy(T[] objectArray,
                                      Predicate<? super T> predicate)

See Also:: Iterate.noneSatisfy(Iterable, Predicate)

noneSatisfyWith

public static <T,P> boolean noneSatisfyWith(T[] objectArray,
                                                  Predicate2<? super T,? super P> predicate,
                                                  P parameter)

See Also:: Iterate.noneSatisfyWith(Iterable, Predicate2, Object)

toMap

public static <K,V> MutableMap<K,V> toMap(V[] objectArray,
                                                      Function<? super V,? extends K> keyFunction)

Iterate over the specified array applying the specified Function to each element to calculate a key and return the results as a HashMap.

toMap

public static <T,K,V> MutableMap<K,V> toMap(T[] objectArray,
                                                              Function<? super T,? extends K> keyFunction,
                                                              Function<? super T,? extends V> valueFunction)

Iterate over the specified array applying the specified Functions to each element to calculate a key and value, and return the results as a Map.

forEachWith

public static <T,P> void forEachWith(T[] objectArray,
                                           Procedure2<? super T,? super P> procedure,
                                           P parameter)

See Also:: Iterate.forEachWith(Iterable, Procedure2, Object)

collectWith

public static <T,P,V> MutableList<V> collectWith(T[] objectArray,
                                                             Function2<? super T,? super P,? extends V> function,
                                                             P parameter)

See Also:: Iterate.collectWith(Iterable, Function2, Object)

collectWith

public static <T,P,V,R extends Collection<V>> R collectWith(T[] objectArray,
                                                                              Function2<? super T,? super P,? extends V> function,
                                                                              P parameter,
                                                                              R targetCollection)

See Also:: Iterate.collectWith(Iterable, Function2, Object, Collection)

injectIntoWith

public static <T,IV,P> IV injectIntoWith(IV injectValue,
                                                     T[] objectArray,
                                                     Function3<? super IV,? super T,? super P,? extends IV> function,
                                                     P parameter)

See Also:: Iterate.injectIntoWith(Object, Iterable, Function3, Object)

take

public static <T> MutableList<T> take(T[] array,
                                      int count)

See Also:: Iterate.take(Iterable, int)

take

public static <T,R extends Collection<T>> R take(T[] array,
                                                       int count,
                                                       R target)

See Also:: Iterate.take(Iterable, int)

drop

public static <T> MutableList<T> drop(T[] array,
                                      int count)

See Also:: Iterate.drop(Iterable, int)

drop

public static <T,R extends Collection<T>> R drop(T[] array,
                                                       int count,
                                                       R target)

See Also:: Iterate.drop(Iterable, int)

groupBy

public static <T,V> FastListMultimap<V,T> groupBy(T[] array,
                                                              Function<? super T,? extends V> function)

See Also:: Iterate.groupBy(Iterable, Function)

groupBy

public static <T,V,R extends MutableMultimap<V,T>> R groupBy(T[] array,
                                                                               Function<? super T,? extends V> function,
                                                                               R target)

See Also:: Iterate.groupBy(Iterable, Function, MutableMultimap)

groupByEach

public static <T,V> FastListMultimap<V,T> groupByEach(T[] array,
                                                                  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(T[] array,
                                                                                   Function<? super T,? extends Iterable<V>> function,
                                                                                   R target)

See Also:: Iterate.groupByEach(Iterable, Function, MutableMultimap)

groupByUniqueKey

public static <T,V> MutableMapIterable<V,T> groupByUniqueKey(T[] array,
                                                                         Function<? super T,? extends V> function)

See Also:: Iterate.groupByUniqueKey(Iterable, Function)

groupByUniqueKey

public static <T,V,R extends MutableMapIterable<V,T>> R groupByUniqueKey(T[] array,
                                                                                           Function<? super T,? extends V> function,
                                                                                           R target)

See Also:: Iterate.groupByUniqueKey(Iterable, Function, MutableMapIterable)

chunk

public static <T> RichIterable<RichIterable<T>> chunk(T[] array,
                                                      int size)

See Also:: Iterate.chunk(Iterable, int)

zip

public static <X,Y> MutableList<Pair<X,Y>> zip(X[] xs,
                                                           Y[] ys)

See Also:: Iterate.zip(Iterable, Iterable)

zip

public static <X,Y,R extends Collection<Pair<X,Y>>> R zip(X[] xs,
                                                                            Y[] ys,
                                                                            R targetCollection)

See Also:: Iterate.zip(Iterable, Iterable, Collection)

zipWithIndex

public static <T> MutableList<Pair<T,Integer>> zipWithIndex(T... array)

See Also:: Iterate.zipWithIndex(Iterable)

zipWithIndex

public static <T,R extends Collection<Pair<T,Integer>>> R zipWithIndex(T[] array,
                                                                                   R targetCollection)

See Also:: Iterate.zipWithIndex(Iterable, Collection)

makeString

public static <T> String makeString(T... array)

See Also:: Iterate.makeString(Iterable)

makeString

public static <T> String makeString(T[] array,
                                    String separator)

See Also:: Iterate.makeString(Iterable, String)

makeString

public static <T> String makeString(T[] array,
                                    String start,
                                    String separator,
                                    String end)

See Also:: Iterate.makeString(Iterable, String, String, String)

appendString

public static <T> void appendString(T[] array,
                                    Appendable appendable)

See Also:: Iterate.appendString(Iterable, Appendable)

appendString

public static <T> void appendString(T[] array,
                                    Appendable appendable,
                                    String separator)

See Also:: Iterate.appendString(Iterable, Appendable, String)

appendString

public static <T> void appendString(T[] array,
                                    Appendable appendable,
                                    String start,
                                    String separator,
                                    String end)

See Also:: Iterate.appendString(Iterable, Appendable, String, String, String)

sumOfInt

public static <T> long sumOfInt(T[] array,
                                IntFunction<? super T> function)

Since:: 6.0
See Also:: Iterate.sumOfInt(Iterable, IntFunction)

sumOfLong

public static <T> long sumOfLong(T[] array,
                                 LongFunction<? super T> function)

Since:: 6.0
See Also:: Iterate.sumOfLong(Iterable, LongFunction)

sumOfFloat

public static <T> double sumOfFloat(T[] array,
                                    FloatFunction<? super T> function)

Since:: 6.0
See Also:: Iterate.sumOfFloat(Iterable, FloatFunction)

sumOfDouble

public static <T> double sumOfDouble(T[] array,
                                     DoubleFunction<? super T> function)

Since:: 6.0
See Also:: Iterate.sumOfDouble(Iterable, DoubleFunction)

sumOfBigDecimal

public static <T> BigDecimal sumOfBigDecimal(T[] array,
                                             Function<? super T,BigDecimal> function)

Since:: 6.0
See Also:: Iterate.sumOfBigDecimal(Iterable, Function)

sumOfBigInteger

public static <T> BigInteger sumOfBigInteger(T[] array,
                                             Function<? super T,BigInteger> function)

Since:: 6.0
See Also:: Iterate.sumOfBigInteger(Iterable, Function)

sumByBigDecimal

public static <V,T> MutableMap<V,BigDecimal> sumByBigDecimal(T[] array,
                                                                         Function<? super T,? extends V> groupBy,
                                                                         Function<? super T,BigDecimal> function)

Since:: 6.0
See Also:: Iterate.sumByBigDecimal(Iterable, Function, Function)

sumByBigInteger

public static <V,T> MutableMap<V,BigInteger> sumByBigInteger(T[] array,
                                                                         Function<? super T,? extends V> groupBy,
                                                                         Function<? super T,BigInteger> function)

Since:: 6.0
See Also:: Iterate.sumByBigInteger(Iterable, Function, Function)

sumByInt

public static <V,T> ObjectLongMap<V> sumByInt(T[] array,
                                                    Function<? super T,? extends V> groupBy,
                                                    IntFunction<? super T> function)

Since:: 6.0
See Also:: Iterate.sumByInt(Iterable, Function, IntFunction)

sumByLong

public static <V,T> ObjectLongMap<V> sumByLong(T[] array,
                                                     Function<? super T,? extends V> groupBy,
                                                     LongFunction<? super T> function)

Since:: 6.0
See Also:: Iterate.sumByLong(Iterable, Function, LongFunction)

sumByFloat

public static <V,T> ObjectDoubleMap<V> sumByFloat(T[] array,
                                                        Function<? super T,? extends V> groupBy,
                                                        FloatFunction<? super T> function)

Since:: 6.0
See Also:: Iterate.sumByFloat(Iterable, Function, FloatFunction)

sumByDouble

public static <V,T> ObjectDoubleMap<V> sumByDouble(T[] array,
                                                         Function<? super T,? extends V> groupBy,
                                                         DoubleFunction<? super T> function)

Since:: 6.0
See Also:: Iterate.sumByDouble(Iterable, Function, DoubleFunction)

Class ArrayIterate

Method Summary

Methods inherited from class java.lang.Object

Method Detail

reverse

sort

minBy

maxBy

min

max

min

max

select

selectWith

selectInstancesOf

count

countWith

selectAndRejectWith

partition

partitionWith

collectIf

select

selectWith

collectIf

reject

rejectWith

reject

rejectWith

addAllTo

collect

collect

collectBoolean

collectBoolean

collectByte

collectByte

collectChar

collectChar

collectDouble

collectDouble

collectFloat

collectFloat

collectInt

collectInt

collectLong

collectLong

collectShort

collectShort

flatCollect

flatCollect

getFirst

getLast

forEach

forEach

forEachInBoth

forEachWithIndex

forEachWithIndex

detect

detectWith

detectOptional

detectWithOptional

detectIfNone

detectWithIfNone

injectInto

injectInto

injectInto

injectInto

injectInto

distinct

distinct

distinct

contains

contains

contains

contains

indexOf

detectIndex

detectIndexWith

detectLastIndex

isEmpty

notEmpty