Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.fastchar.utils.FastArrayUtils Maven / Gradle / Ivy
package com.fastchar.utils;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
/**
* from org.apache.commons.lang3
*/
public class FastArrayUtils {
public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
public static final Class[] EMPTY_CLASS_ARRAY = new Class[0];
public static final String[] EMPTY_STRING_ARRAY = new String[0];
public static final long[] EMPTY_LONG_ARRAY = new long[0];
public static final Long[] EMPTY_LONG_OBJECT_ARRAY = new Long[0];
public static final int[] EMPTY_INT_ARRAY = new int[0];
public static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = new Integer[0];
public static final short[] EMPTY_SHORT_ARRAY = new short[0];
public static final Short[] EMPTY_SHORT_OBJECT_ARRAY = new Short[0];
public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
public static final Byte[] EMPTY_BYTE_OBJECT_ARRAY = new Byte[0];
public static final double[] EMPTY_DOUBLE_ARRAY = new double[0];
public static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY = new Double[0];
public static final float[] EMPTY_FLOAT_ARRAY = new float[0];
public static final Float[] EMPTY_FLOAT_OBJECT_ARRAY = new Float[0];
public static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0];
public static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY = new Boolean[0];
public static final char[] EMPTY_CHAR_ARRAY = new char[0];
public static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY = new Character[0];
public static Object[] nullToEmpty(Object[] array) {
return isEmpty(array) ? EMPTY_OBJECT_ARRAY : array;
}
public static Class[] nullToEmpty(Class[] array) {
return isEmpty((Object[])array) ? EMPTY_CLASS_ARRAY : array;
}
public static boolean isEmpty(Object[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(long[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(int[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(short[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(char[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(byte[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(double[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(float[] array) {
return array == null || array.length == 0;
}
public static boolean isEmpty(boolean[] array) {
return array == null || array.length == 0;
}
public static boolean isNotEmpty(T[] array) {
return array != null && array.length != 0;
}
public static boolean isNotEmpty(long[] array) {
return array != null && array.length != 0;
}
public static boolean isNotEmpty(int[] array) {
return array != null && array.length != 0;
}
public static boolean isNotEmpty(short[] array) {
return array != null && array.length != 0;
}
public static boolean isNotEmpty(char[] array) {
return array != null && array.length != 0;
}
public static boolean isNotEmpty(byte[] array) {
return array != null && array.length != 0;
}
public static boolean isNotEmpty(double[] array) {
return array != null && array.length != 0;
}
public static boolean isNotEmpty(float[] array) {
return array != null && array.length != 0;
}
public static boolean isNotEmpty(boolean[] array) {
return array != null && array.length != 0;
}
public static String[] trimEmpty(String[] array) {
List newArray = new ArrayList();
for (String s : array) {
if (FastStringUtils.isNotEmpty(s)) {
newArray.add(s);
}
}
return newArray.toArray(new String[]{});
}
public static int indexOf(Object[] array, Object objectToFind, int startIndex) {
if (array == null) {
return -1;
} else {
if (startIndex < 0) {
startIndex = 0;
}
int i;
if (objectToFind == null) {
for(i = startIndex; i < array.length; ++i) {
if (array[i] == null) {
return i;
}
}
} else if (array.getClass().getComponentType().isInstance(objectToFind)) {
for(i = startIndex; i < array.length; ++i) {
if (objectToFind.equals(array[i])) {
return i;
}
}
}
return -1;
}
}
public static boolean contains(Object[] array, Object objectToFind) {
return indexOf(array, objectToFind) != -1;
}
public static boolean contains(long[] array, long valueToFind) {
return indexOf(array, valueToFind) != -1;
}
public static int indexOf(long[] array, long valueToFind) {
return indexOf(array, valueToFind, 0);
}
public static boolean contains(double[] array, double valueToFind) {
return indexOf(array, valueToFind) != -1;
}
public static boolean contains(double[] array, double valueToFind, double tolerance) {
return indexOf(array, valueToFind, 0, tolerance) != -1;
}
public static int indexOf(double[] array, double valueToFind) {
return indexOf(array, valueToFind, 0);
}
public static int indexOf(double[] array, double valueToFind, double tolerance) {
return indexOf(array, valueToFind, 0, tolerance);
}
public static int indexOf(long[] array, long valueToFind, int startIndex) {
if (array == null) {
return -1;
} else {
if (startIndex < 0) {
startIndex = 0;
}
for(int i = startIndex; i < array.length; ++i) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
}
public static int indexOf(char[] array, char valueToFind, int startIndex) {
if (array == null) {
return -1;
} else {
if (startIndex < 0) {
startIndex = 0;
}
for(int i = startIndex; i < array.length; ++i) {
if (valueToFind == array[i]) {
return i;
}
}
return -1;
}
}
public static int indexOf(double[] array, double valueToFind, int startIndex, double tolerance) {
if (isEmpty(array)) {
return -1;
} else {
if (startIndex < 0) {
startIndex = 0;
}
double min = valueToFind - tolerance;
double max = valueToFind + tolerance;
for(int i = startIndex; i < array.length; ++i) {
if (array[i] >= min && array[i] <= max) {
return i;
}
}
return -1;
}
}
public static int indexOf(Object[] array, Object objectToFind) {
return indexOf(array, objectToFind, 0);
}
public static boolean[] toPrimitive(Boolean[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_BOOLEAN_ARRAY;
} else {
boolean[] result = new boolean[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static boolean[] toPrimitive(Boolean[] array, boolean valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_BOOLEAN_ARRAY;
} else {
boolean[] result = new boolean[array.length];
for(int i = 0; i < array.length; ++i) {
Boolean b = array[i];
result[i] = b == null ? valueForNull : b;
}
return result;
}
}
public static Boolean[] toObject(boolean[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_BOOLEAN_OBJECT_ARRAY;
} else {
Boolean[] result = new Boolean[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i] ? Boolean.TRUE : Boolean.FALSE;
}
return result;
}
}
public static char[] toPrimitive(Character[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_CHAR_ARRAY;
} else {
char[] result = new char[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static char[] toPrimitive(Character[] array, char valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_CHAR_ARRAY;
} else {
char[] result = new char[array.length];
for(int i = 0; i < array.length; ++i) {
Character b = array[i];
result[i] = b == null ? valueForNull : b;
}
return result;
}
}
public static Character[] toObject(char[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_CHARACTER_OBJECT_ARRAY;
} else {
Character[] result = new Character[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static long[] toPrimitive(Long[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_LONG_ARRAY;
} else {
long[] result = new long[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static long[] toPrimitive(Long[] array, long valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_LONG_ARRAY;
} else {
long[] result = new long[array.length];
for(int i = 0; i < array.length; ++i) {
Long b = array[i];
result[i] = b == null ? valueForNull : b;
}
return result;
}
}
public static Long[] toObject(long[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_LONG_OBJECT_ARRAY;
} else {
Long[] result = new Long[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static int[] toPrimitive(Integer[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_INT_ARRAY;
} else {
int[] result = new int[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static int[] toPrimitive(Integer[] array, int valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_INT_ARRAY;
} else {
int[] result = new int[array.length];
for(int i = 0; i < array.length; ++i) {
Integer b = array[i];
result[i] = b == null ? valueForNull : b;
}
return result;
}
}
public static Integer[] toObject(int[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_INTEGER_OBJECT_ARRAY;
} else {
Integer[] result = new Integer[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static short[] toPrimitive(Short[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_SHORT_ARRAY;
} else {
short[] result = new short[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static short[] toPrimitive(Short[] array, short valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_SHORT_ARRAY;
} else {
short[] result = new short[array.length];
for(int i = 0; i < array.length; ++i) {
Short b = array[i];
result[i] = b == null ? valueForNull : b;
}
return result;
}
}
public static Short[] toObject(short[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_SHORT_OBJECT_ARRAY;
} else {
Short[] result = new Short[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static byte[] toPrimitive(Byte[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_BYTE_ARRAY;
} else {
byte[] result = new byte[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static byte[] toPrimitive(Byte[] array, byte valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_BYTE_ARRAY;
} else {
byte[] result = new byte[array.length];
for(int i = 0; i < array.length; ++i) {
Byte b = array[i];
result[i] = b == null ? valueForNull : b;
}
return result;
}
}
public static Byte[] toObject(byte[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_BYTE_OBJECT_ARRAY;
} else {
Byte[] result = new Byte[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static double[] toPrimitive(Double[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_DOUBLE_ARRAY;
} else {
double[] result = new double[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static double[] toPrimitive(Double[] array, double valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_DOUBLE_ARRAY;
} else {
double[] result = new double[array.length];
for(int i = 0; i < array.length; ++i) {
Double b = array[i];
result[i] = b == null ? valueForNull : b;
}
return result;
}
}
public static Double[] toObject(double[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_DOUBLE_OBJECT_ARRAY;
} else {
Double[] result = new Double[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static float[] toPrimitive(Float[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_FLOAT_ARRAY;
} else {
float[] result = new float[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static float[] toPrimitive(Float[] array, float valueForNull) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_FLOAT_ARRAY;
} else {
float[] result = new float[array.length];
for(int i = 0; i < array.length; ++i) {
Float b = array[i];
result[i] = b == null ? valueForNull : b;
}
return result;
}
}
public static Float[] toObject(float[] array) {
if (array == null) {
return null;
} else if (array.length == 0) {
return EMPTY_FLOAT_OBJECT_ARRAY;
} else {
Float[] result = new Float[array.length];
for(int i = 0; i < array.length; ++i) {
result[i] = array[i];
}
return result;
}
}
public static T[] subarray(T[] array, int startIndexInclusive, int endIndexExclusive) {
if (array == null) {
return null;
} else {
if (startIndexInclusive < 0) {
startIndexInclusive = 0;
}
if (endIndexExclusive > array.length) {
endIndexExclusive = array.length;
}
int newSize = endIndexExclusive - startIndexInclusive;
Class type = array.getClass().getComponentType();
Object[] subarray;
if (newSize <= 0) {
subarray = (Object[]) Array.newInstance(type, 0);
return (T[]) subarray;
} else {
subarray = (Object[]) Array.newInstance(type, newSize);
System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
return (T[]) subarray;
}
}
}
public static long[] subarray(long[] array, int startIndexInclusive, int endIndexExclusive) {
if (array == null) {
return null;
} else {
if (startIndexInclusive < 0) {
startIndexInclusive = 0;
}
if (endIndexExclusive > array.length) {
endIndexExclusive = array.length;
}
int newSize = endIndexExclusive - startIndexInclusive;
if (newSize <= 0) {
return EMPTY_LONG_ARRAY;
} else {
long[] subarray = new long[newSize];
System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
return subarray;
}
}
}
public static int[] subarray(int[] array, int startIndexInclusive, int endIndexExclusive) {
if (array == null) {
return null;
} else {
if (startIndexInclusive < 0) {
startIndexInclusive = 0;
}
if (endIndexExclusive > array.length) {
endIndexExclusive = array.length;
}
int newSize = endIndexExclusive - startIndexInclusive;
if (newSize <= 0) {
return EMPTY_INT_ARRAY;
} else {
int[] subarray = new int[newSize];
System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
return subarray;
}
}
}
public static short[] subarray(short[] array, int startIndexInclusive, int endIndexExclusive) {
if (array == null) {
return null;
} else {
if (startIndexInclusive < 0) {
startIndexInclusive = 0;
}
if (endIndexExclusive > array.length) {
endIndexExclusive = array.length;
}
int newSize = endIndexExclusive - startIndexInclusive;
if (newSize <= 0) {
return EMPTY_SHORT_ARRAY;
} else {
short[] subarray = new short[newSize];
System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
return subarray;
}
}
}
public static char[] subarray(char[] array, int startIndexInclusive, int endIndexExclusive) {
if (array == null) {
return null;
} else {
if (startIndexInclusive < 0) {
startIndexInclusive = 0;
}
if (endIndexExclusive > array.length) {
endIndexExclusive = array.length;
}
int newSize = endIndexExclusive - startIndexInclusive;
if (newSize <= 0) {
return EMPTY_CHAR_ARRAY;
} else {
char[] subarray = new char[newSize];
System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
return subarray;
}
}
}
public static byte[] subarray(byte[] array, int startIndexInclusive, int endIndexExclusive) {
if (array == null) {
return null;
} else {
if (startIndexInclusive < 0) {
startIndexInclusive = 0;
}
if (endIndexExclusive > array.length) {
endIndexExclusive = array.length;
}
int newSize = endIndexExclusive - startIndexInclusive;
if (newSize <= 0) {
return EMPTY_BYTE_ARRAY;
} else {
byte[] subarray = new byte[newSize];
System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
return subarray;
}
}
}
public static double[] subarray(double[] array, int startIndexInclusive, int endIndexExclusive) {
if (array == null) {
return null;
} else {
if (startIndexInclusive < 0) {
startIndexInclusive = 0;
}
if (endIndexExclusive > array.length) {
endIndexExclusive = array.length;
}
int newSize = endIndexExclusive - startIndexInclusive;
if (newSize <= 0) {
return EMPTY_DOUBLE_ARRAY;
} else {
double[] subarray = new double[newSize];
System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
return subarray;
}
}
}
public static float[] subarray(float[] array, int startIndexInclusive, int endIndexExclusive) {
if (array == null) {
return null;
} else {
if (startIndexInclusive < 0) {
startIndexInclusive = 0;
}
if (endIndexExclusive > array.length) {
endIndexExclusive = array.length;
}
int newSize = endIndexExclusive - startIndexInclusive;
if (newSize <= 0) {
return EMPTY_FLOAT_ARRAY;
} else {
float[] subarray = new float[newSize];
System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
return subarray;
}
}
}
public static boolean[] subarray(boolean[] array, int startIndexInclusive, int endIndexExclusive) {
if (array == null) {
return null;
} else {
if (startIndexInclusive < 0) {
startIndexInclusive = 0;
}
if (endIndexExclusive > array.length) {
endIndexExclusive = array.length;
}
int newSize = endIndexExclusive - startIndexInclusive;
if (newSize <= 0) {
return EMPTY_BOOLEAN_ARRAY;
} else {
boolean[] subarray = new boolean[newSize];
System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
return subarray;
}
}
}
private static Object copyArrayGrow1(Object array, Class newArrayComponentType) {
if (array != null) {
int arrayLength = Array.getLength(array);
Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
System.arraycopy(array, 0, newArray, 0, arrayLength);
return newArray;
} else {
return Array.newInstance(newArrayComponentType, 1);
}
}
public static T[] add(T[] array, int index, T element) {
Class clss = null;
if (array != null) {
clss = array.getClass().getComponentType();
} else {
if (element == null) {
throw new IllegalArgumentException("Array and element cannot both be null");
}
clss = element.getClass();
}
T[] newArray = (T[]) add(array, index, element, clss);
return newArray;
}
public static boolean[] add(boolean[] array, int index, boolean element) {
return (boolean[])((boolean[])add(array, index, element, Boolean.TYPE));
}
public static char[] add(char[] array, int index, char element) {
return (char[])((char[])add(array, index, element, Character.TYPE));
}
public static byte[] add(byte[] array, int index, byte element) {
return (byte[])((byte[])add(array, index, element, Byte.TYPE));
}
public static short[] add(short[] array, int index, short element) {
return (short[])((short[])add(array, index, element, Short.TYPE));
}
public static int[] add(int[] array, int index, int element) {
return (int[])((int[])add(array, index, element, Integer.TYPE));
}
public static long[] add(long[] array, int index, long element) {
return (long[])((long[])add(array, index, element, Long.TYPE));
}
public static float[] add(float[] array, int index, float element) {
return (float[])((float[])add(array, index, element, Float.TYPE));
}
public static double[] add(double[] array, int index, double element) {
return (double[])((double[])add(array, index, element, Double.TYPE));
}
private static Object add(Object array, int index, Object element, Class clss) {
if (array == null) {
if (index != 0) {
throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");
} else {
Object joinedArray = Array.newInstance(clss, 1);
Array.set(joinedArray, 0, element);
return joinedArray;
}
} else {
int length = Array.getLength(array);
if (index <= length && index >= 0) {
Object result = Array.newInstance(clss, length + 1);
System.arraycopy(array, 0, result, 0, index);
Array.set(result, index, element);
if (index < length) {
System.arraycopy(array, index, result, index + 1, length - index);
}
return result;
} else {
throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
}
}
}
}
