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

Class InternalArrayIterate

java.lang.Object

org.eclipse.collections.impl.utility.internal.InternalArrayIterate

public final class InternalArrayIterate
extends Object

Method Summary

Modifier and Type	Method	Description
static <T> boolean	allSatisfy(T[] array, int size, Predicate<? super T> predicate)
static <T,P> boolean	allSatisfyWith(T[] array, int size, Predicate2<? super T,? super P> predicate, P parameter)
static <T> boolean	anySatisfy(T[] array, int size, Predicate<? super T> predicate)
static <T,P> boolean	anySatisfyWith(T[] array, int size, Predicate2<? super T,? super P> predicate, P parameter)
static <T> void	appendString(ListIterable<T> iterable, T[] array, int size, Appendable appendable, String start, String separator, String end)
static <T> boolean	arrayEqualsList(T[] array, int size, List<?> list)
static <T> void	batchForEach(Procedure<? super T> procedure, T[] array, int size, int sectionIndex, int sectionCount)
static <T,V,R extends Collection<V>> R	collect(T[] array, int size, Function<? super T,? extends V> function, R target)
static <T,V,R extends Collection<V>> R	collectIf(T[] array, int size, Predicate<? super T> predicate, Function<? super T,? extends V> function, R target)
static <T,P,V,R extends Collection<V>> R	collectWith(T[] array, int size, Function2<? super T,? super P,? extends V> function, P parameter, R target)
static <T,V,R extends Collection<V>> R	collectWithIndex(T[] array, int size, ObjectIntToObjectFunction<? super T,? extends V> function, R target)
static <T,P> boolean	corresponds(T[] array, int size, OrderedIterable<P> other, Predicate2<? super T,? super P> predicate)
static <T> int	count(T[] array, int size, Predicate<? super T> predicate)
static <T,P> int	countWith(T[] array, int size, Predicate2<? super T,? super P> predicate, P parameter)
static <T> T	detect(T[] array, int size, Predicate<? super T> predicate)
static <T> int	detectIndex(T[] objectArray, int size, Predicate<? super T> predicate)
static <T> int	detectLastIndex(T[] objectArray, int size, Predicate<? super T> predicate)
static <T> Optional<T>	detectOptional(T[] array, int size, Predicate<? super T> predicate)
static <T,P> T	detectWith(T[] array, int size, Predicate2<? super T,? super P> predicate, P parameter)
static <T,P> Optional<T>	detectWithOptional(T[] array, int size, Predicate2<? super T,? super P> predicate, P parameter)
static <T> FastList<T>	distinct(T[] objectArray, int size)
static <T> FastList<T>	distinct(T[] objectArray, int size, HashingStrategy<? super T> hashingStrategy)
static <T,R extends List<T>> R	distinct(T[] objectArray, int size, R targetList)	Deprecated. in 7.0.
static <T,V,R extends Collection<V>> R	flatCollect(T[] array, int size, Function<? super T,? extends Iterable<V>> function, R target)
static <T> void	forEachWithIndex(T[] objectArray, int size, ObjectIntProcedure<? super T> objectIntProcedure)
static <T> void	forEachWithIndexWithoutChecks(T[] objectArray, int from, int to, ObjectIntProcedure<? super T> objectIntProcedure)
static <T> void	forEachWithoutChecks(T[] objectArray, int from, int to, Procedure<? super T> procedure)
static <T,V,R extends MutableMultimap<V,T>> R	groupBy(T[] array, int size, Function<? super T,? extends V> function, R target)
static <T,V,R extends MutableMultimap<V,T>> R	groupByEach(T[] array, int size, Function<? super T,? extends Iterable<V>> function, R target)
static <T,K,R extends MutableMapIterable<K,T>> R	groupByUniqueKey(T[] array, int size, Function<? super T,? extends K> function, R target)
static int	indexOf(Object[] array, int size, Object object)
static int	lastIndexOf(Object[] array, int size, Object object)
static <T> T	max(T[] array, int size)
static <T> T	max(T[] array, int size, Comparator<? super T> comparator)
static <T,V extends Comparable<? super V>> T	maxBy(T[] array, int size, Function<? super T,? extends V> function)
static <T> T	min(T[] array, int size)
static <T> T	min(T[] array, int size, Comparator<? super T> comparator)
static <T,V extends Comparable<? super V>> T	minBy(T[] array, int size, Function<? super T,? extends V> function)
static <T> boolean	noneSatisfy(T[] array, int size, Predicate<? super T> predicate)
static <T,P> boolean	noneSatisfyWith(T[] array, int size, Predicate2<? super T,? super P> predicate, P parameter)
static <T> PartitionFastList<T>	partition(T[] array, int size, Predicate<? super T> predicate)
static <T,P> PartitionFastList<T>	partitionWith(T[] array, int size, Predicate2<? super T,? super P> predicate, P parameter)
static <T> Optional<T>	reduce(T[] items, int size, BinaryOperator<T> accumulator)
static <R,T> R	reduceInPlace(T[] items, int size, Supplier<R> supplier, BiConsumer<R,? super T> accumulator)
static <R,A,T> R	reduceInPlace(T[] items, int size, Collector<? super T,A,R> collector)
static <T,R extends Collection<T>> R	reject(T[] array, int size, Predicate<? super T> predicate, R target)
static <T,P,R extends Collection<T>> R	rejectWith(T[] array, int size, Predicate2<? super T,? super P> predicate, P parameter, R target)
static <T> void	replaceAll(T[] items, int size, UnaryOperator<T> operator)
static <T,R extends Collection<T>> R	select(T[] array, int size, Predicate<? super T> predicate, R target)
static <T,P> Twin<MutableList<T>>	selectAndRejectWith(T[] objectArray, int size, Predicate2<? super T,? super P> predicate, P parameter)	Deprecated. since 6.0 use RichIterable.partitionWith(Predicate2, Object) instead.
static <T> FastList<T>	selectInstancesOf(Object[] array, int size, Class<T> clazz)
static <T,P,R extends Collection<T>> R	selectWith(T[] array, int size, Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)
static <T> boolean	shortCircuit(T[] array, int size, Predicate<? super T> predicate, boolean expected, boolean onShortCircuit, boolean atEnd)
static <T,P> boolean	shortCircuitWith(T[] array, int size, Predicate2<? super T,? super P> predicate2, P parameter, boolean expected, boolean onShortCircuit, boolean atEnd)
static <V,T> MutableObjectDoubleMap<V>	sumByDouble(T[] array, int size, Function<? super T,? extends V> groupBy, DoubleFunction<? super T> function)
static <V,T> MutableObjectDoubleMap<V>	sumByFloat(T[] array, int size, Function<? super T,? extends V> groupBy, FloatFunction<? super T> function)
static <V,T> MutableObjectLongMap<V>	sumByInt(T[] array, int size, Function<? super T,? extends V> groupBy, IntFunction<? super T> function)
static <V,T> MutableObjectLongMap<V>	sumByLong(T[] array, int size, Function<? super T,? extends V> groupBy, LongFunction<? super T> function)
static <T> DoubleSummaryStatistics	summarizeDouble(T[] items, int size, DoubleFunction<? super T> function)
static <T> DoubleSummaryStatistics	summarizeFloat(T[] items, int size, FloatFunction<? super T> function)
static <T> IntSummaryStatistics	summarizeInt(T[] items, int size, IntFunction<? super T> function)
static <T> LongSummaryStatistics	summarizeLong(T[] items, int size, LongFunction<? super T> function)
static <T> double	sumOfDouble(T[] array, int size, DoubleFunction<? super T> function)
static <T> double	sumOfFloat(T[] array, int size, FloatFunction<? super T> function)
static <T> long	sumOfInt(T[] array, int size, IntFunction<? super T> function)
static <T> long	sumOfLong(T[] array, int size, LongFunction<? super T> function)

Methods inherited from class java.lang.Object

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

Method Detail

arrayEqualsList

public static <T> boolean arrayEqualsList(T[] array,
                                          int size,
                                          List<?> list)

forEachWithoutChecks

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

forEachWithIndexWithoutChecks

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

batchForEach

public static <T> void batchForEach(Procedure<? super T> procedure,
                                    T[] array,
                                    int size,
                                    int sectionIndex,
                                    int sectionCount)

groupBy

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

groupByEach

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

groupByUniqueKey

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

partition

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

partitionWith

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

selectAndRejectWith

@Deprecated
public static <T,P> Twin<MutableList<T>> selectAndRejectWith(T[] objectArray,
                                                             int size,
                                                             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)

indexOf

public static int indexOf(Object[] array,
                          int size,
                          Object object)

lastIndexOf

public static int lastIndexOf(Object[] array,
                              int size,
                              Object object)

select

public static <T,R extends Collection<T>> R select(T[] array,
                                                   int size,
                                                   Predicate<? super T> predicate,
                                                   R target)

selectWith

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

reject

public static <T,R extends Collection<T>> R reject(T[] array,
                                                   int size,
                                                   Predicate<? super T> predicate,
                                                   R target)

rejectWith

public static <T,P,R extends Collection<T>> R rejectWith(T[] array,
                                                         int size,
                                                         Predicate2<? super T,? super P> predicate,
                                                         P parameter,
                                                         R target)

selectInstancesOf

public static <T> FastList<T> selectInstancesOf(Object[] array,
                                                int size,
                                                Class<T> clazz)

collect

public static <T,V,R extends Collection<V>> R collect(T[] array,
                                                      int size,
                                                      Function<? super T,? extends V> function,
                                                      R target)

collectWithIndex

public static <T,V,R extends Collection<V>> R collectWithIndex(T[] array,
                                                               int size,
                                                               ObjectIntToObjectFunction<? super T,? extends V> function,
                                                               R target)

Since:

9.1.

flatCollect

public static <T,V,R extends Collection<V>> R flatCollect(T[] array,
                                                          int size,
                                                          Function<? super T,? extends Iterable<V>> function,
                                                          R target)

collectWith

public static <T,P,V,R extends Collection<V>> R collectWith(T[] array,
                                                            int size,
                                                            Function2<? super T,? super P,? extends V> function,
                                                            P parameter,
                                                            R target)

collectIf

public static <T,V,R extends Collection<V>> R collectIf(T[] array,
                                                        int size,
                                                        Predicate<? super T> predicate,
                                                        Function<? super T,? extends V> function,
                                                        R target)

min

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

max

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

min

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

max

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

minBy

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

maxBy

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

count

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

countWith

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

shortCircuit

public static <T> boolean shortCircuit(T[] array,
                                       int size,
                                       Predicate<? super T> predicate,
                                       boolean expected,
                                       boolean onShortCircuit,
                                       boolean atEnd)

shortCircuitWith

public static <T,P> boolean shortCircuitWith(T[] array,
                                             int size,
                                             Predicate2<? super T,? super P> predicate2,
                                             P parameter,
                                             boolean expected,
                                             boolean onShortCircuit,
                                             boolean atEnd)

corresponds

public static <T,P> boolean corresponds(T[] array,
                                        int size,
                                        OrderedIterable<P> other,
                                        Predicate2<? super T,? super P> predicate)

anySatisfy

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

anySatisfyWith

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

allSatisfy

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

allSatisfyWith

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

noneSatisfy

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

noneSatisfyWith

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

detect

public static <T> T detect(T[] array,
                           int size,
                           Predicate<? super T> predicate)

detectWith

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

detectOptional

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

detectWithOptional

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

appendString

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

detectIndex

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

detectLastIndex

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

forEachWithIndex

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

distinct

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

Deprecated. in 7.0.

distinct

public static <T> FastList<T> distinct(T[] objectArray,
                                       int size)

Since:

7.0.

distinct

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

Since:

7.0.

sumOfInt

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

sumOfLong

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

sumOfFloat

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

sumOfDouble

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

sumByInt

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

sumByLong

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

sumByFloat

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

sumByDouble

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

summarizeInt

public static <T> IntSummaryStatistics summarizeInt(T[] items,
                                                    int size,
                                                    IntFunction<? super T> function)

Since:

8.0

summarizeFloat

public static <T> DoubleSummaryStatistics summarizeFloat(T[] items,
                                                         int size,
                                                         FloatFunction<? super T> function)

Since:

8.0

summarizeLong

public static <T> LongSummaryStatistics summarizeLong(T[] items,
                                                      int size,
                                                      LongFunction<? super T> function)

Since:

8.0

summarizeDouble

public static <T> DoubleSummaryStatistics summarizeDouble(T[] items,
                                                          int size,
                                                          DoubleFunction<? super T> function)

Since:

8.0

reduce

public static <T> Optional<T> reduce(T[] items,
                                     int size,
                                     BinaryOperator<T> accumulator)

Since:

8.0

reduceInPlace

public static <R,A,T> R reduceInPlace(T[] items,
                                      int size,
                                      Collector<? super T,A,R> collector)

Since:

8.0

reduceInPlace

public static <R,T> R reduceInPlace(T[] items,
                                    int size,
                                    Supplier<R> supplier,
                                    BiConsumer<R,? super T> accumulator)

Since:

8.0

replaceAll

public static <T> void replaceAll(T[] items,
                                  int size,
                                  UnaryOperator<T> operator)

Since:

10.0 - Provided for convenience for array based containers