org.eclipse.collections.impl.utility.ArrayIterate Maven / Gradle / Ivy
/*
* Copyright (c) 2016 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.impl.utility;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import org.eclipse.collections.api.RichIterable;
import org.eclipse.collections.api.block.HashingStrategy;
import org.eclipse.collections.api.block.function.Function;
import org.eclipse.collections.api.block.function.Function2;
import org.eclipse.collections.api.block.function.Function3;
import org.eclipse.collections.api.block.function.primitive.BooleanFunction;
import org.eclipse.collections.api.block.function.primitive.ByteFunction;
import org.eclipse.collections.api.block.function.primitive.CharFunction;
import org.eclipse.collections.api.block.function.primitive.DoubleFunction;
import org.eclipse.collections.api.block.function.primitive.DoubleObjectToDoubleFunction;
import org.eclipse.collections.api.block.function.primitive.FloatFunction;
import org.eclipse.collections.api.block.function.primitive.FloatObjectToFloatFunction;
import org.eclipse.collections.api.block.function.primitive.IntFunction;
import org.eclipse.collections.api.block.function.primitive.IntObjectToIntFunction;
import org.eclipse.collections.api.block.function.primitive.LongFunction;
import org.eclipse.collections.api.block.function.primitive.LongObjectToLongFunction;
import org.eclipse.collections.api.block.function.primitive.ShortFunction;
import org.eclipse.collections.api.block.predicate.Predicate;
import org.eclipse.collections.api.block.predicate.Predicate2;
import org.eclipse.collections.api.block.procedure.Procedure;
import org.eclipse.collections.api.block.procedure.Procedure2;
import org.eclipse.collections.api.block.procedure.primitive.ObjectIntProcedure;
import org.eclipse.collections.api.collection.primitive.MutableBooleanCollection;
import org.eclipse.collections.api.collection.primitive.MutableByteCollection;
import org.eclipse.collections.api.collection.primitive.MutableCharCollection;
import org.eclipse.collections.api.collection.primitive.MutableDoubleCollection;
import org.eclipse.collections.api.collection.primitive.MutableFloatCollection;
import org.eclipse.collections.api.collection.primitive.MutableIntCollection;
import org.eclipse.collections.api.collection.primitive.MutableLongCollection;
import org.eclipse.collections.api.collection.primitive.MutableShortCollection;
import org.eclipse.collections.api.list.MutableList;
import org.eclipse.collections.api.list.primitive.MutableBooleanList;
import org.eclipse.collections.api.list.primitive.MutableByteList;
import org.eclipse.collections.api.list.primitive.MutableCharList;
import org.eclipse.collections.api.list.primitive.MutableDoubleList;
import org.eclipse.collections.api.list.primitive.MutableFloatList;
import org.eclipse.collections.api.list.primitive.MutableIntList;
import org.eclipse.collections.api.list.primitive.MutableLongList;
import org.eclipse.collections.api.list.primitive.MutableShortList;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.api.map.primitive.ObjectDoubleMap;
import org.eclipse.collections.api.map.primitive.ObjectLongMap;
import org.eclipse.collections.api.multimap.MutableMultimap;
import org.eclipse.collections.api.tuple.Pair;
import org.eclipse.collections.api.tuple.Twin;
import org.eclipse.collections.impl.block.factory.Functions0;
import org.eclipse.collections.impl.block.factory.Predicates2;
import org.eclipse.collections.impl.block.factory.Procedures2;
import org.eclipse.collections.impl.block.procedure.MapCollectProcedure;
import org.eclipse.collections.impl.factory.Lists;
import org.eclipse.collections.impl.list.mutable.FastList;
import org.eclipse.collections.impl.list.mutable.primitive.BooleanArrayList;
import org.eclipse.collections.impl.list.mutable.primitive.ByteArrayList;
import org.eclipse.collections.impl.list.mutable.primitive.CharArrayList;
import org.eclipse.collections.impl.list.mutable.primitive.DoubleArrayList;
import org.eclipse.collections.impl.list.mutable.primitive.FloatArrayList;
import org.eclipse.collections.impl.list.mutable.primitive.IntArrayList;
import org.eclipse.collections.impl.list.mutable.primitive.LongArrayList;
import org.eclipse.collections.impl.list.mutable.primitive.ShortArrayList;
import org.eclipse.collections.impl.map.mutable.UnifiedMap;
import org.eclipse.collections.impl.multimap.list.FastListMultimap;
import org.eclipse.collections.impl.partition.list.PartitionFastList;
import org.eclipse.collections.impl.tuple.Tuples;
import org.eclipse.collections.impl.utility.internal.InternalArrayIterate;
/**
* This utility class provides iteration pattern implementations that work with Java arrays.
*
* @since 1.0
*/
public final class ArrayIterate
{
private ArrayIterate()
{
throw new AssertionError("Suppress default constructor for noninstantiability");
}
public static void reverse(T[] array, int size)
{
int mid = size / 2;
int j = size - 1;
for (int i = 0; i < mid; i++, j--)
{
T one = array[i];
T two = array[j];
array[i] = two;
array[j] = one;
}
}
/**
* Inline calls to appropriate Arrays.sort() method which now uses TimSort by default since Java 8.
*
* @deprecated in 7.0. Use {@link Arrays#sort(Object[], int, int)} or {@link Arrays#sort(Object[], int, int, Comparator)} instead.
*/
@Deprecated
public static void sort(T[] array, int size, Comparator comparator)
{
if (comparator == null)
{
Arrays.sort(array, 0, size); // handles case size < 2 in Java 8 ComparableTimSort
}
else
{
Arrays.sort(array, 0, size, comparator); // handles case size < 2 in Java 8 TimSort
}
}
public static > T minBy(T[] array, Function function)
{
return InternalArrayIterate.minBy(array, array.length, function);
}
public static > T maxBy(T[] array, Function function)
{
return InternalArrayIterate.maxBy(array, array.length, function);
}
/**
* @see Iterate#min(Iterable, Comparator)
*/
public static T min(T[] array, Comparator comparator)
{
return InternalArrayIterate.min(array, array.length, comparator);
}
/**
* @see Iterate#max(Iterable, Comparator)
*/
public static T max(T[] array, Comparator comparator)
{
return InternalArrayIterate.max(array, array.length, comparator);
}
/**
* @see Iterate#min(Iterable)
*/
public static T min(T... array)
{
return InternalArrayIterate.min(array, array.length);
}
/**
* @see Iterate#max(Iterable)
*/
public static T max(T... array)
{
return InternalArrayIterate.max(array, array.length);
}
/**
* @see Iterate#select(Iterable, Predicate)
*/
public static MutableList select(T[] objectArray, Predicate predicate)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a select on null");
}
return ArrayIterate.select(objectArray, predicate, FastList.newList());
}
/**
* @see Iterate#selectWith(Iterable, Predicate2, Object)
*/
public static MutableList selectWith(
T[] objectArray,
Predicate2 predicate,
P parameter)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a selectWith on null");
}
return ArrayIterate.selectWith(objectArray, predicate, parameter, FastList.newList());
}
/**
* @see Iterate#selectInstancesOf(Iterable, Class)
*/
public static FastList selectInstancesOf(Object[] objectArray, Class clazz)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a selectInstancesOf on null");
}
return InternalArrayIterate.selectInstancesOf(objectArray, objectArray.length, clazz);
}
/**
* @see Iterate#count(Iterable, Predicate)
*/
public static int count(T[] objectArray, Predicate predicate)
{
if (objectArray == null)
{
return 0;
}
return InternalArrayIterate.count(objectArray, objectArray.length, predicate);
}
/**
* @see Iterate#countWith(Iterable, Predicate2, Object)
*/
public static int countWith(
T[] objectArray,
Predicate2 predicate,
P parameter)
{
if (objectArray == null)
{
return 0;
}
return InternalArrayIterate.countWith(objectArray, objectArray.length, predicate, parameter);
}
/**
* @see Iterate#selectAndRejectWith(Iterable, Predicate2, Object)
* @deprecated since 6.0 use {@link RichIterable#partitionWith(Predicate2, Object)} instead.
*/
@Deprecated
public static Twin> selectAndRejectWith(
T[] objectArray,
Predicate2 predicate,
P parameter)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a selectAndRejectWith on null");
}
return InternalArrayIterate.selectAndRejectWith(objectArray, objectArray.length, predicate, parameter);
}
/**
* @see Iterate#partition(Iterable, Predicate)
*/
public static PartitionFastList partition(T[] array, Predicate predicate)
{
if (array == null)
{
throw new IllegalArgumentException("Cannot perform a partition on null");
}
return InternalArrayIterate.partition(array, array.length, predicate);
}
public static PartitionFastList partitionWith(T[] array, Predicate2 predicate, P parameter)
{
if (array == null)
{
throw new IllegalArgumentException("Cannot perform a partitionWith on null");
}
return InternalArrayIterate.partitionWith(array, array.length, predicate, parameter);
}
/**
* @see Iterate#collectIf(Iterable, Predicate, Function)
*/
public static MutableList collectIf(
T[] objectArray,
Predicate predicate,
Function function)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectIf on null");
}
return ArrayIterate.collectIf(
objectArray,
predicate,
function,
FastList.newList(objectArray.length));
}
/**
* @see Iterate#select(Iterable, Predicate, Collection)
*/
public static > R select(
T[] objectArray,
Predicate predicate,
R targetCollection)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a select on null");
}
return InternalArrayIterate.select(objectArray, objectArray.length, predicate, targetCollection);
}
/**
* @see Iterate#selectWith(Iterable, Predicate2, Object, Collection)
*/
public static > R selectWith(
T[] objectArray,
Predicate2 predicate,
P parameter,
R targetCollection)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a selectWith on null");
}
return InternalArrayIterate.selectWith(objectArray, objectArray.length, predicate, parameter, targetCollection);
}
/**
* @see Iterate#collectIf(Iterable, Predicate, Function, Collection)
*/
public static > R collectIf(
T[] objectArray,
Predicate predicate,
Function function,
R targetCollection)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectIf on null");
}
return InternalArrayIterate.collectIf(objectArray, objectArray.length, predicate, function, targetCollection);
}
/**
* @see Iterate#reject(Iterable, Predicate)
*/
public static MutableList reject(T[] objectArray, Predicate predicate)
{
return ArrayIterate.reject(objectArray, predicate, FastList.newList());
}
/**
* @see Iterate#rejectWith(Iterable, Predicate2, Object)
*/
public static MutableList rejectWith(
T[] objectArray,
Predicate2 predicate,
P parameter)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a rejectWith on null");
}
return ArrayIterate.rejectWith(
objectArray,
predicate,
parameter,
FastList.newList());
}
/**
* @see Iterate#reject(Iterable, Predicate, Collection)
*/
public static > R reject(
T[] objectArray,
Predicate predicate,
R targetCollection)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a reject on null");
}
return InternalArrayIterate.reject(objectArray, objectArray.length, predicate, targetCollection);
}
/**
* @see Iterate#rejectWith(Iterable, Predicate2, Object, Collection)
*/
public static > R rejectWith(
T[] objectArray,
Predicate2 predicate,
P parameter,
R targetCollection)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a rejectWith on null");
}
return InternalArrayIterate.rejectWith(objectArray, objectArray.length, predicate, parameter, targetCollection);
}
/**
* @see Iterate#addAllTo(Iterable, Collection)
*/
public static > R addAllTo(T[] objectArray, R targetCollection)
{
ArrayIterate.forEachWith(objectArray, Procedures2.addToCollection(), targetCollection);
return targetCollection;
}
/**
* @see Iterate#collect(Iterable, Function)
*/
public static MutableList collect(
T[] objectArray,
Function function)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collect on null");
}
return ArrayIterate.collect(objectArray, function, FastList.newList(objectArray.length));
}
/**
* @see Iterate#collect(Iterable, Function, Collection)
*/
public static > R collect(
T[] objectArray,
Function function,
R targetCollection)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collect on null");
}
return InternalArrayIterate.collect(objectArray, objectArray.length, function, targetCollection);
}
/**
* @see Iterate#collectBoolean(Iterable, BooleanFunction)
*/
public static MutableBooleanList collectBoolean(T[] objectArray, BooleanFunction booleanFunction)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectBoolean on null");
}
return ArrayIterate.collectBoolean(objectArray, booleanFunction, new BooleanArrayList(objectArray.length));
}
/**
* @see Iterate#collectBoolean(Iterable, BooleanFunction, MutableBooleanCollection)
*/
public static R collectBoolean(
T[] objectArray,
BooleanFunction booleanFunction,
R target)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectBoolean on null");
}
for (T each : objectArray)
{
target.add(booleanFunction.booleanValueOf(each));
}
return target;
}
/**
* @see Iterate#collectByte(Iterable, ByteFunction)
*/
public static MutableByteList collectByte(T[] objectArray, ByteFunction byteFunction)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectByte on null");
}
return ArrayIterate.collectByte(objectArray, byteFunction, new ByteArrayList(objectArray.length));
}
/**
* @see Iterate#collectByte(Iterable, ByteFunction, MutableByteCollection)
*/
public static R collectByte(
T[] objectArray,
ByteFunction byteFunction,
R target)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectByte on null");
}
for (T each : objectArray)
{
target.add(byteFunction.byteValueOf(each));
}
return target;
}
/**
* @see Iterate#collectChar(Iterable, CharFunction)
*/
public static MutableCharList collectChar(T[] objectArray, CharFunction charFunction)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectChar on null");
}
return ArrayIterate.collectChar(objectArray, charFunction, new CharArrayList(objectArray.length));
}
/**
* @see Iterate#collectChar(Iterable, CharFunction, MutableCharCollection)
*/
public static R collectChar(
T[] objectArray,
CharFunction charFunction,
R target)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectChar on null");
}
for (T each : objectArray)
{
target.add(charFunction.charValueOf(each));
}
return target;
}
/**
* @see Iterate#collectDouble(Iterable, DoubleFunction)
*/
public static MutableDoubleList collectDouble(T[] objectArray, DoubleFunction doubleFunction)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectDouble on null");
}
return ArrayIterate.collectDouble(objectArray, doubleFunction, new DoubleArrayList(objectArray.length));
}
/**
* @see Iterate#collectDouble(Iterable, DoubleFunction, MutableDoubleCollection)
*/
public static R collectDouble(
T[] objectArray,
DoubleFunction doubleFunction,
R target)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectDouble on null");
}
for (T each : objectArray)
{
target.add(doubleFunction.doubleValueOf(each));
}
return target;
}
/**
* @see Iterate#collectFloat(Iterable, FloatFunction)
*/
public static MutableFloatList collectFloat(T[] objectArray, FloatFunction floatFunction)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectFloat on null");
}
return ArrayIterate.collectFloat(objectArray, floatFunction, new FloatArrayList(objectArray.length));
}
/**
* @see Iterate#collectFloat(Iterable, FloatFunction, MutableFloatCollection)
*/
public static R collectFloat(
T[] objectArray,
FloatFunction floatFunction,
R target)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectFloat on null");
}
for (T each : objectArray)
{
target.add(floatFunction.floatValueOf(each));
}
return target;
}
/**
* @see Iterate#collectInt(Iterable, IntFunction)
*/
public static MutableIntList collectInt(
T[] objectArray,
IntFunction intFunction)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectInt on null");
}
return ArrayIterate.collectInt(objectArray, intFunction, new IntArrayList(objectArray.length));
}
/**
* @see Iterate#collectInt(Iterable, IntFunction, MutableIntCollection)
*/
public static R collectInt(
T[] objectArray,
IntFunction intFunction,
R target)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectInt on null");
}
for (T each : objectArray)
{
target.add(intFunction.intValueOf(each));
}
return target;
}
/**
* @see Iterate#collectLong(Iterable, LongFunction)
*/
public static MutableLongList collectLong(
T[] objectArray,
LongFunction longFunction)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectLong on null");
}
return ArrayIterate.collectLong(objectArray, longFunction, new LongArrayList(objectArray.length));
}
/**
* @see Iterate#collectLong(Iterable, LongFunction, MutableLongCollection)
*/
public static R collectLong(
T[] objectArray,
LongFunction longFunction,
R target)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectLong on null");
}
for (T each : objectArray)
{
target.add(longFunction.longValueOf(each));
}
return target;
}
/**
* @see Iterate#collectShort(Iterable, ShortFunction)
*/
public static MutableShortList collectShort(
T[] objectArray,
ShortFunction shortFunction)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectShort on null");
}
return ArrayIterate.collectShort(objectArray, shortFunction, new ShortArrayList(objectArray.length));
}
/**
* @see Iterate#collectShort(Iterable, ShortFunction, MutableShortCollection)
*/
public static R collectShort(
T[] objectArray,
ShortFunction shortFunction,
R target)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectShort on null");
}
for (T each : objectArray)
{
target.add(shortFunction.shortValueOf(each));
}
return target;
}
/**
* @see Iterate#flatCollect(Iterable, Function)
*/
public static MutableList flatCollect(
T[] objectArray,
Function> function)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a flatCollect on null");
}
return ArrayIterate.flatCollect(objectArray, function, FastList.newList(objectArray.length));
}
public static > R flatCollect(
T[] objectArray,
Function> function,
R targetCollection)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a flatCollect on null");
}
return InternalArrayIterate.flatCollect(objectArray, objectArray.length, function, targetCollection);
}
/**
* Returns the first element of an array. This method is null safe.
*/
public static T getFirst(T[] objectArray)
{
if (ArrayIterate.notEmpty(objectArray))
{
return objectArray[0];
}
return null;
}
/**
* Returns the last element of an Array. This method is null safe.
*/
public static T getLast(T[] objectArray)
{
if (ArrayIterate.notEmpty(objectArray))
{
return objectArray[objectArray.length - 1];
}
return null;
}
/**
* @see Iterate#forEach(Iterable, Procedure)
*/
public static void forEach(T[] objectArray, Procedure procedure)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a forEach on null");
}
if (ArrayIterate.notEmpty(objectArray))
{
for (T each : objectArray)
{
procedure.value(each);
}
}
}
/**
* Iterates over the section of the list covered by the specified inclusive indexes. The indexes are
* both inclusive.
*/
public static void forEach(T[] objectArray, int from, int to, Procedure procedure)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a forEach on null");
}
ListIterate.rangeCheck(from, to, objectArray.length);
InternalArrayIterate.forEachWithoutChecks(objectArray, from, to, procedure);
}
/**
* @see ListIterate#forEachInBoth(List, List, Procedure2)
*/
public static void forEachInBoth(
T1[] objectArray1,
T2[] objectArray2,
Procedure2 procedure)
{
if (objectArray1 != null && objectArray2 != null)
{
if (objectArray1.length == objectArray2.length)
{
int size = objectArray1.length;
for (int i = 0; i < size; i++)
{
procedure.value(objectArray1[i], objectArray2[i]);
}
}
else
{
throw new RuntimeException("Attempt to call forEachInBoth with two arrays of different sizes :"
+ objectArray1.length + ':' + objectArray2.length);
}
}
}
/**
* @see Iterate#forEachWithIndex(Iterable, ObjectIntProcedure)
*/
public static void forEachWithIndex(T[] objectArray, ObjectIntProcedure objectIntProcedure)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a forEachWithIndex on null");
}
InternalArrayIterate.forEachWithIndex(objectArray, objectArray.length, objectIntProcedure);
}
/**
* Iterates over the section of the list covered by the specified inclusive indexes. The indexes are
* both inclusive.
*/
public static void forEachWithIndex(
T[] objectArray,
int from, int to,
ObjectIntProcedure objectIntProcedure)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a forEachWithIndex on null");
}
ListIterate.rangeCheck(from, to, objectArray.length);
InternalArrayIterate.forEachWithIndexWithoutChecks(objectArray, from, to, objectIntProcedure);
}
/**
* @see Iterate#detect(Iterable, Predicate)
*/
public static T detect(T[] objectArray, Predicate predicate)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a detect on null");
}
return InternalArrayIterate.detect(objectArray, objectArray.length, predicate);
}
/**
* @see Iterate#detectWith(Iterable, Predicate2, Object)
*/
public static T detectWith(
T[] objectArray,
Predicate2 predicate,
P parameter)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a detectWith on null");
}
return InternalArrayIterate.detectWith(objectArray, objectArray.length, predicate, parameter);
}
/**
* @see Iterate#detectIfNone(Iterable, Predicate, Object)
*/
public static T detectIfNone(
T[] objectArray,
Predicate predicate,
T ifNone)
{
T result = ArrayIterate.detect(objectArray, predicate);
return result == null ? ifNone : result;
}
/**
* @see Iterate#detectWithIfNone(Iterable, Predicate2, Object, Object)
*/
public static T detectWithIfNone(
T[] objectArray,
Predicate2 predicate,
P parameter,
T ifNone)
{
T result = ArrayIterate.detectWith(objectArray, predicate, parameter);
return result == null ? ifNone : result;
}
/**
* @see Iterate#injectInto(Object, Iterable, Function2)
*/
public static IV injectInto(
IV injectValue,
T[] objectArray,
Function2 function)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform an injectInto on null");
}
IV result = injectValue;
for (T each : objectArray)
{
result = function.value(result, each);
}
return result;
}
/**
* @see Iterate#injectInto(int, Iterable, IntObjectToIntFunction)
*/
public static int injectInto(
int injectValue,
T[] objectArray,
IntObjectToIntFunction function)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform an injectInto on null");
}
int result = injectValue;
if (ArrayIterate.notEmpty(objectArray))
{
for (T each : objectArray)
{
result = function.intValueOf(result, each);
}
}
return result;
}
/**
* @see Iterate#injectInto(long, Iterable, LongObjectToLongFunction)
*/
public static long injectInto(
long injectValue,
T[] objectArray,
LongObjectToLongFunction function)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform an injectInto on null");
}
long result = injectValue;
if (ArrayIterate.notEmpty(objectArray))
{
for (T each : objectArray)
{
result = function.longValueOf(result, each);
}
}
return result;
}
/**
* @see Iterate#injectInto(float, Iterable, FloatObjectToFloatFunction)
* @since 6.0
*/
public static float injectInto(float injectValue, T[] objectArray, FloatObjectToFloatFunction function)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform an injectInto on null");
}
float result = injectValue;
if (ArrayIterate.notEmpty(objectArray))
{
for (T each : objectArray)
{
result = function.floatValueOf(result, each);
}
}
return result;
}
/**
* @see Iterate#injectInto(double, Iterable, DoubleObjectToDoubleFunction)
*/
public static double injectInto(
double injectValue,
T[] objectArray,
DoubleObjectToDoubleFunction function)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform an injectInto on null");
}
double result = injectValue;
if (ArrayIterate.notEmpty(objectArray))
{
for (T each : objectArray)
{
result = function.doubleValueOf(result, each);
}
}
return result;
}
/**
* @deprecated in 7.0.
*/
@Deprecated
public static > R distinct(T[] objectArray, R targetList)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a distinct on null");
}
return InternalArrayIterate.distinct(objectArray, objectArray.length, targetList);
}
/**
* @since 7.0.
*/
public static MutableList distinct(T[] objectArray)
{
return ArrayIterate.distinct(objectArray, FastList.newList());
}
/**
* @since 7.0.
*/
public static MutableList distinct(T[] objectArray, HashingStrategy hashingStrategy)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a distinct on null");
}
return InternalArrayIterate.distinct(objectArray, objectArray.length, hashingStrategy);
}
/**
* Returns true if the specified array contains the specified element.
*/
public static boolean contains(T[] objectArray, T value)
{
return ArrayIterate.anySatisfyWith(objectArray, Predicates2.equal(), value);
}
/**
* Returns true if the specified int array contains the specified int element.
*/
public static boolean contains(int[] intArray, int value)
{
for (int each : intArray)
{
if (each == value)
{
return true;
}
}
return false;
}
/**
* Returns true if the specified double array contains the specified double element.
*/
public static boolean contains(double[] doubleArray, double value)
{
for (double each : doubleArray)
{
if (Double.doubleToLongBits(each) == Double.doubleToLongBits(value))
{
return true;
}
}
return false;
}
/**
* Returns true if the specified long array contains the specified long element.
*/
public static boolean contains(long[] longArray, long value)
{
for (long each : longArray)
{
if (each == value)
{
return true;
}
}
return false;
}
/**
* Searches for the first occurrence of the given argument, testing
* for equality using the equals method.
*/
public static int indexOf(T[] objectArray, T elem)
{
return InternalArrayIterate.indexOf(objectArray, objectArray.length, elem);
}
/**
* Returns the first index where the predicate evaluates to true. Returns -1 for no matches.
*/
public static int detectIndex(T[] objectArray, Predicate predicate)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a detectIndex on null");
}
return InternalArrayIterate.detectIndex(objectArray, objectArray.length, predicate);
}
/**
* Searches for the first index where the predicate evaluates to true. Returns -1 for no matches.
*/
public static int detectIndexWith(
T[] objectArray,
Predicate2 predicate,
IV injectedValue)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a detectIndexWith on null");
}
for (int i = 0; i < objectArray.length; i++)
{
if (predicate.accept(objectArray[i], injectedValue))
{
return i;
}
}
return -1;
}
/**
* Returns the last index where the predicate evaluates to true.
* Returns -1 for no matches.
*/
public static int detectLastIndex(T[] objectArray, Predicate predicate)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a detectLastIndex on null");
}
return InternalArrayIterate.detectLastIndex(objectArray, objectArray.length, predicate);
}
/**
* A null safe form of isEmpty. Null or length of zero returns true.
*/
public static boolean isEmpty(Object[] array)
{
return array == null || array.length == 0;
}
/**
* A null safe form of notEmpty. The opposite of isEmpty is returned.
*/
public static boolean notEmpty(Object[] array)
{
return array != null && array.length > 0;
}
/**
* Return the size of the array.
*/
public static int size(Object[] array)
{
return array == null ? 0 : array.length;
}
/**
* @see Iterate#anySatisfy(Iterable, Predicate)
*/
public static boolean anySatisfy(T[] objectArray, Predicate predicate)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a anySatisfy on null");
}
return InternalArrayIterate.anySatisfy(objectArray, objectArray.length, predicate);
}
/**
* @see Iterate#anySatisfyWith(Iterable, Predicate2, Object)
*/
public static boolean anySatisfyWith(
T[] objectArray,
Predicate2 predicate,
P parameter)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a anySatisfyWith on null");
}
return InternalArrayIterate.anySatisfyWith(objectArray, objectArray.length, predicate, parameter);
}
/**
* @see Iterate#allSatisfy(Iterable, Predicate)
*/
public static boolean allSatisfy(T[] objectArray, Predicate predicate)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a allSatisfy on null");
}
return InternalArrayIterate.allSatisfy(objectArray, objectArray.length, predicate);
}
/**
* @see Iterate#allSatisfyWith(Iterable, Predicate2, Object)
*/
public static boolean allSatisfyWith(
T[] objectArray,
Predicate2 predicate,
P parameter)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a allSatisfyWith on null");
}
return InternalArrayIterate.allSatisfyWith(objectArray, objectArray.length, predicate, parameter);
}
/**
* @see Iterate#noneSatisfy(Iterable, Predicate)
*/
public static boolean noneSatisfy(T[] objectArray, Predicate predicate)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a noneSatisfy on null");
}
return InternalArrayIterate.noneSatisfy(objectArray, objectArray.length, predicate);
}
/**
* @see Iterate#noneSatisfyWith(Iterable, Predicate2, Object)
*/
public static boolean noneSatisfyWith(
T[] objectArray,
Predicate2 predicate,
P parameter)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a noneSatisfyWith on null");
}
return InternalArrayIterate.noneSatisfyWith(objectArray, objectArray.length, predicate, parameter);
}
/**
* Iterate over the specified array applying the specified Function to each element to calculate a key
* and return the results as a HashMap.
*/
public static MutableMap toMap(
V[] objectArray,
Function keyFunction)
{
MutableMap map = UnifiedMap.newMap();
Procedure procedure = new MapCollectProcedure(map, keyFunction);
ArrayIterate.forEach(objectArray, procedure);
return map;
}
/**
* 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.
*/
public static MutableMap toMap(
T[] objectArray,
Function keyFunction,
Function valueFunction)
{
MutableMap map = UnifiedMap.newMap();
Procedure procedure = new MapCollectProcedure(map, keyFunction, valueFunction);
ArrayIterate.forEach(objectArray, procedure);
return map;
}
/**
* @see Iterate#forEachWith(Iterable, Procedure2, Object)
*/
public static void forEachWith(
T[] objectArray,
Procedure2 procedure,
P parameter)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a forEachWith on null");
}
if (ArrayIterate.notEmpty(objectArray))
{
for (T each : objectArray)
{
procedure.value(each, parameter);
}
}
}
/**
* @see Iterate#collectWith(Iterable, Function2, Object)
*/
public static MutableList collectWith(
T[] objectArray,
Function2 function,
P parameter)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectWith on null");
}
return ArrayIterate.collectWith(objectArray, function, parameter, FastList.newList(objectArray.length));
}
/**
* @see Iterate#collectWith(Iterable, Function2, Object, Collection)
*/
public static > R collectWith(
T[] objectArray,
Function2 function,
P parameter,
R targetCollection)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform a collectWith on null");
}
return InternalArrayIterate.collectWith(objectArray, objectArray.length, function, parameter, targetCollection);
}
/**
* @see Iterate#injectIntoWith(Object, Iterable, Function3, Object)
*/
public static IV injectIntoWith(
IV injectValue,
T[] objectArray,
Function3 function,
P parameter)
{
if (objectArray == null)
{
throw new IllegalArgumentException("Cannot perform an injectIntoWith on null");
}
IV result = injectValue;
if (ArrayIterate.notEmpty(objectArray))
{
for (T each : objectArray)
{
result = function.value(result, each, parameter);
}
}
return result;
}
/**
* @see Iterate#take(Iterable, int)
*/
public static MutableList take(T[] array, int count)
{
if (count < 0)
{
throw new IllegalArgumentException("Count must be greater than zero, but was: " + count);
}
return ArrayIterate.take(array, count, FastList.newList(Math.min(array.length, count)));
}
/**
* @see Iterate#take(Iterable, int)
*/
public static > R take(T[] array, int count, R target)
{
if (count < 0)
{
throw new IllegalArgumentException("Count must be greater than zero, but was: " + count);
}
int end = Math.min(array.length, count);
for (int i = 0; i < end; i++)
{
target.add(array[i]);
}
return target;
}
/**
* @see Iterate#drop(Iterable, int)
*/
public static MutableList drop(T[] array, int count)
{
if (count < 0)
{
throw new IllegalArgumentException("Count must be greater than zero, but was: " + count);
}
return ArrayIterate.drop(array, count, FastList.newList(array.length - Math.min(array.length, count)));
}
/**
* @see Iterate#drop(Iterable, int)
*/
public static > R drop(T[] array, int count, R target)
{
if (count < 0)
{
throw new IllegalArgumentException("Count must be greater than zero, but was: " + count);
}
for (int i = count; i < array.length; i++)
{
target.add(array[i]);
}
return target;
}
/**
* @see Iterate#groupBy(Iterable, Function)
*/
public static FastListMultimap groupBy(
T[] array,
Function function)
{
return ArrayIterate.groupBy(array, function, FastListMultimap.newMultimap());
}
/**
* @see Iterate#groupBy(Iterable, Function, MutableMultimap)
*/
public static > R groupBy(
T[] array,
Function function,
R target)
{
return InternalArrayIterate.groupBy(array, array.length, function, target);
}
/**
* @see Iterate#groupByEach(Iterable, Function)
*/
public static FastListMultimap groupByEach(
T[] array,
Function> function)
{
return ArrayIterate.groupByEach(array, function, FastListMultimap.newMultimap());
}
/**
* @see Iterate#groupByEach(Iterable, Function, MutableMultimap)
*/
public static > R groupByEach(
T[] array,
Function> function,
R target)
{
return InternalArrayIterate.groupByEach(array, array.length, function, target);
}
/**
* @see Iterate#groupByUniqueKey(Iterable, Function)
*/
public static MutableMap groupByUniqueKey(
T[] array,
Function function)
{
return ArrayIterate.groupByUniqueKey(array, function, UnifiedMap.newMap());
}
/**
* @see Iterate#groupByUniqueKey(Iterable, Function, MutableMap)
*/
public static > R groupByUniqueKey(
T[] array,
Function function,
R target)
{
if (array == null)
{
throw new IllegalArgumentException("Cannot perform a groupByUniqueKey on null");
}
return InternalArrayIterate.groupByUniqueKey(array, array.length, function, target);
}
/**
* @see Iterate#chunk(Iterable, int)
*/
public static RichIterable> chunk(T[] array, int size)
{
if (size <= 0)
{
throw new IllegalArgumentException("Size for groups must be positive but was: " + size);
}
int index = 0;
MutableList> result = Lists.mutable.empty();
while (index < array.length)
{
MutableList batch = Lists.mutable.empty();
for (int i = 0; i < size && index < array.length; i++)
{
batch.add(array[index]);
index++;
}
result.add(batch);
}
return result;
}
/**
* @see Iterate#zip(Iterable, Iterable)
*/
public static MutableList> zip(X[] xs, Y[] ys)
{
return ArrayIterate.zip(xs, ys, FastList.>newList());
}
/**
* @see Iterate#zip(Iterable, Iterable, Collection)
*/
public static >> R zip(X[] xs, Y[] ys, R targetCollection)
{
int size = Math.min(xs.length, ys.length);
for (int i = 0; i < size; i++)
{
targetCollection.add(Tuples.pair(xs[i], ys[i]));
}
return targetCollection;
}
/**
* @see Iterate#zipWithIndex(Iterable)
*/
public static MutableList> zipWithIndex(T... array)
{
return ArrayIterate.zipWithIndex(array, FastList.>newList());
}
/**
* @see Iterate#zipWithIndex(Iterable, Collection)
*/
public static >> R zipWithIndex(T[] array, R targetCollection)
{
for (int i = 0; i < array.length; i++)
{
targetCollection.add(Tuples.pair(array[i], i));
}
return targetCollection;
}
/**
* @see Iterate#makeString(Iterable)
*/
public static String makeString(T... array)
{
return ArrayIterate.makeString(array, ", ");
}
/**
* @see Iterate#makeString(Iterable, String)
*/
public static String makeString(T[] array, String separator)
{
return ArrayIterate.makeString(array, "", separator, "");
}
/**
* @see Iterate#makeString(Iterable, String, String, String)
*/
public static String makeString(T[] array, String start, String separator, String end)
{
Appendable stringBuilder = new StringBuilder();
ArrayIterate.appendString(array, stringBuilder, start, separator, end);
return stringBuilder.toString();
}
/**
* @see Iterate#appendString(Iterable, Appendable)
*/
public static void appendString(T[] array, Appendable appendable)
{
ArrayIterate.appendString(array, appendable, ", ");
}
/**
* @see Iterate#appendString(Iterable, Appendable, String)
*/
public static void appendString(T[] array, Appendable appendable, String separator)
{
ArrayIterate.appendString(array, appendable, "", separator, "");
}
/**
* @see Iterate#appendString(Iterable, Appendable, String, String, String)
*/
public static void appendString(
T[] array,
Appendable appendable,
String start,
String separator,
String end)
{
try
{
appendable.append(start);
if (array.length > 0)
{
appendable.append(String.valueOf(array[0]));
int size = array.length;
for (int i = 1; i < size; i++)
{
appendable.append(separator);
appendable.append(String.valueOf(array[i]));
}
}
appendable.append(end);
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
/**
* @see Iterate#sumOfInt(Iterable, IntFunction)
* @since 6.0
*/
public static long sumOfInt(T[] array, IntFunction function)
{
return InternalArrayIterate.sumOfInt(array, array.length, function);
}
/**
* @see Iterate#sumOfLong(Iterable, LongFunction)
* @since 6.0
*/
public static long sumOfLong(T[] array, LongFunction function)
{
return InternalArrayIterate.sumOfLong(array, array.length, function);
}
/**
* @see Iterate#sumOfFloat(Iterable, FloatFunction)
* @since 6.0
*/
public static double sumOfFloat(T[] array, FloatFunction function)
{
return InternalArrayIterate.sumOfFloat(array, array.length, function);
}
/**
* @see Iterate#sumOfDouble(Iterable, DoubleFunction)
* @since 6.0
*/
public static double sumOfDouble(T[] array, DoubleFunction function)
{
return InternalArrayIterate.sumOfDouble(array, array.length, function);
}
/**
* @see Iterate#sumOfBigDecimal(Iterable, Function)
* @since 6.0
*/
public static BigDecimal sumOfBigDecimal(T[] array, Function function)
{
BigDecimal result = BigDecimal.ZERO;
for (T each : array)
{
result = result.add(function.valueOf(each));
}
return result;
}
/**
* @see Iterate#sumOfBigInteger(Iterable, Function)
* @since 6.0
*/
public static BigInteger sumOfBigInteger(T[] array, Function function)
{
BigInteger result = BigInteger.ZERO;
for (T each : array)
{
result = result.add(function.valueOf(each));
}
return result;
}
/**
* @see Iterate#sumByBigDecimal(Iterable, Function, Function)
* @since 6.0
*/
public static MutableMap sumByBigDecimal(T[] array, Function groupBy, final Function function)
{
MutableMap result = UnifiedMap.newMap();
for (final T each : array)
{
result.updateValue(groupBy.valueOf(each), Functions0.zeroBigDecimal(), new Function()
{
public BigDecimal valueOf(BigDecimal original)
{
return original.add(function.valueOf(each));
}
});
}
return result;
}
/**
* @see Iterate#sumByBigInteger(Iterable, Function, Function)
* @since 6.0
*/
public static MutableMap sumByBigInteger(T[] array, Function groupBy, final Function function)
{
MutableMap result = UnifiedMap.newMap();
for (final T each : array)
{
result.updateValue(groupBy.valueOf(each), Functions0.zeroBigInteger(), new Function()
{
public BigInteger valueOf(BigInteger original)
{
return original.add(function.valueOf(each));
}
});
}
return result;
}
/**
* @see Iterate#sumByInt(Iterable, Function, IntFunction)
* @since 6.0
*/
public static ObjectLongMap sumByInt(T[] array, Function groupBy, IntFunction function)
{
return InternalArrayIterate.sumByInt(array, array.length, groupBy, function);
}
/**
* @see Iterate#sumByLong(Iterable, Function, LongFunction)
* @since 6.0
*/
public static ObjectLongMap sumByLong(T[] array, Function groupBy, LongFunction function)
{
return InternalArrayIterate.sumByLong(array, array.length, groupBy, function);
}
/**
* @see Iterate#sumByFloat(Iterable, Function, FloatFunction)
* @since 6.0
*/
public static ObjectDoubleMap sumByFloat(T[] array, Function groupBy, FloatFunction function)
{
return InternalArrayIterate.sumByFloat(array, array.length, groupBy, function);
}
/**
* @see Iterate#sumByDouble(Iterable, Function, DoubleFunction)
* @since 6.0
*/
public static ObjectDoubleMap sumByDouble(T[] array, Function groupBy, DoubleFunction function)
{
return InternalArrayIterate.sumByDouble(array, array.length, groupBy, function);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy