name.remal.ArrayUtils Maven / Gradle / Ivy
package name.remal;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.jetbrains.annotations.Contract;
import java.util.Arrays;
import java.lang.reflect.Array;
import java.util.Objects;
import static name.remal.UncheckedCast.uncheckedCast;
@SuppressWarnings("SimplifiableIfStatement")
public class ArrayUtils {
@Nonnull
@Contract(pure = true)
static boolean[] concatArray(@Nonnull boolean[] array1, @Nonnull boolean[] array2) {
if (0 == array1.length) return array2;
if (0 == array2.length) return array1;
boolean[] result = new boolean[array1.length + array2.length];
System.arraycopy(array1, 0, result, 0, array1.length);
System.arraycopy(array2, 0, result, array1.length, array2.length);
return result;
}
@Nonnull
@Contract(pure = true)
public static boolean[] concat(@Nonnull boolean[] array1, @Nonnull boolean... array2) {
return concatArray(array1, array2);
}
@Nonnull
@Contract(pure = true)
static byte[] concatArray(@Nonnull byte[] array1, @Nonnull byte[] array2) {
if (0 == array1.length) return array2;
if (0 == array2.length) return array1;
byte[] result = new byte[array1.length + array2.length];
System.arraycopy(array1, 0, result, 0, array1.length);
System.arraycopy(array2, 0, result, array1.length, array2.length);
return result;
}
@Nonnull
@Contract(pure = true)
public static byte[] concat(@Nonnull byte[] array1, @Nonnull byte... array2) {
return concatArray(array1, array2);
}
@Nonnull
@Contract(pure = true)
static char[] concatArray(@Nonnull char[] array1, @Nonnull char[] array2) {
if (0 == array1.length) return array2;
if (0 == array2.length) return array1;
char[] result = new char[array1.length + array2.length];
System.arraycopy(array1, 0, result, 0, array1.length);
System.arraycopy(array2, 0, result, array1.length, array2.length);
return result;
}
@Nonnull
@Contract(pure = true)
public static char[] concat(@Nonnull char[] array1, @Nonnull char... array2) {
return concatArray(array1, array2);
}
@Nonnull
@Contract(pure = true)
static double[] concatArray(@Nonnull double[] array1, @Nonnull double[] array2) {
if (0 == array1.length) return array2;
if (0 == array2.length) return array1;
double[] result = new double[array1.length + array2.length];
System.arraycopy(array1, 0, result, 0, array1.length);
System.arraycopy(array2, 0, result, array1.length, array2.length);
return result;
}
@Nonnull
@Contract(pure = true)
public static double[] concat(@Nonnull double[] array1, @Nonnull double... array2) {
return concatArray(array1, array2);
}
@Nonnull
@Contract(pure = true)
static float[] concatArray(@Nonnull float[] array1, @Nonnull float[] array2) {
if (0 == array1.length) return array2;
if (0 == array2.length) return array1;
float[] result = new float[array1.length + array2.length];
System.arraycopy(array1, 0, result, 0, array1.length);
System.arraycopy(array2, 0, result, array1.length, array2.length);
return result;
}
@Nonnull
@Contract(pure = true)
public static float[] concat(@Nonnull float[] array1, @Nonnull float... array2) {
return concatArray(array1, array2);
}
@Nonnull
@Contract(pure = true)
static int[] concatArray(@Nonnull int[] array1, @Nonnull int[] array2) {
if (0 == array1.length) return array2;
if (0 == array2.length) return array1;
int[] result = new int[array1.length + array2.length];
System.arraycopy(array1, 0, result, 0, array1.length);
System.arraycopy(array2, 0, result, array1.length, array2.length);
return result;
}
@Nonnull
@Contract(pure = true)
public static int[] concat(@Nonnull int[] array1, @Nonnull int... array2) {
return concatArray(array1, array2);
}
@Nonnull
@Contract(pure = true)
static long[] concatArray(@Nonnull long[] array1, @Nonnull long[] array2) {
if (0 == array1.length) return array2;
if (0 == array2.length) return array1;
long[] result = new long[array1.length + array2.length];
System.arraycopy(array1, 0, result, 0, array1.length);
System.arraycopy(array2, 0, result, array1.length, array2.length);
return result;
}
@Nonnull
@Contract(pure = true)
public static long[] concat(@Nonnull long[] array1, @Nonnull long... array2) {
return concatArray(array1, array2);
}
@Nonnull
@Contract(pure = true)
static short[] concatArray(@Nonnull short[] array1, @Nonnull short[] array2) {
if (0 == array1.length) return array2;
if (0 == array2.length) return array1;
short[] result = new short[array1.length + array2.length];
System.arraycopy(array1, 0, result, 0, array1.length);
System.arraycopy(array2, 0, result, array1.length, array2.length);
return result;
}
@Nonnull
@Contract(pure = true)
public static short[] concat(@Nonnull short[] array1, @Nonnull short... array2) {
return concatArray(array1, array2);
}
@Nonnull
@Contract(pure = true)
static T[] concatArray(@Nonnull T[] array1, @Nonnull O[] array2) {
Class type = array1.getClass().getComponentType();
Class otherType = array2.getClass().getComponentType();
if (!type.isAssignableFrom(otherType)) throw new IllegalArgumentException("Array of " + type + " can't be concatenated with array of " + otherType);
if (0 == array1.length) return array2;
if (0 == array2.length) return array1;
T[] result = uncheckedCast(Array.newInstance(type, array1.length + array2.length));
System.arraycopy(array1, 0, result, 0, array1.length);
System.arraycopy(array2, 0, result, array1.length, array2.length);
return result;
}
@Nonnull
@SafeVarargs
@Contract(pure = true)
public static T[] concat(@Nonnull T[] array1, @Nonnull O... array2) {
return concatArray(array1, array2);
}
@Contract(value = "null,null->true; null,!null->false; !null,null->false", pure = true)
public static boolean arrayEquals(@Nullable boolean[] array1, @Nullable boolean[] array2) {
if (array1 == array2) return true;
if (null == array1 || null == array2) return false;
return Arrays.equals(array1, array2);
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable boolean[] array1, @Nullable byte[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable boolean[] array1, @Nullable char[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable boolean[] array1, @Nullable double[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable boolean[] array1, @Nullable float[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable boolean[] array1, @Nullable int[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable boolean[] array1, @Nullable long[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable boolean[] array1, @Nullable short[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable byte[] array1, @Nullable boolean[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; null,!null->false; !null,null->false", pure = true)
public static boolean arrayEquals(@Nullable byte[] array1, @Nullable byte[] array2) {
if (array1 == array2) return true;
if (null == array1 || null == array2) return false;
return Arrays.equals(array1, array2);
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable byte[] array1, @Nullable char[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable byte[] array1, @Nullable double[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable byte[] array1, @Nullable float[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable byte[] array1, @Nullable int[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable byte[] array1, @Nullable long[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable byte[] array1, @Nullable short[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable char[] array1, @Nullable boolean[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable char[] array1, @Nullable byte[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; null,!null->false; !null,null->false", pure = true)
public static boolean arrayEquals(@Nullable char[] array1, @Nullable char[] array2) {
if (array1 == array2) return true;
if (null == array1 || null == array2) return false;
return Arrays.equals(array1, array2);
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable char[] array1, @Nullable double[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable char[] array1, @Nullable float[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable char[] array1, @Nullable int[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable char[] array1, @Nullable long[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable char[] array1, @Nullable short[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable double[] array1, @Nullable boolean[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable double[] array1, @Nullable byte[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable double[] array1, @Nullable char[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; null,!null->false; !null,null->false", pure = true)
public static boolean arrayEquals(@Nullable double[] array1, @Nullable double[] array2) {
if (array1 == array2) return true;
if (null == array1 || null == array2) return false;
return Arrays.equals(array1, array2);
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable double[] array1, @Nullable float[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable double[] array1, @Nullable int[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable double[] array1, @Nullable long[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable double[] array1, @Nullable short[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable float[] array1, @Nullable boolean[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable float[] array1, @Nullable byte[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable float[] array1, @Nullable char[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable float[] array1, @Nullable double[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; null,!null->false; !null,null->false", pure = true)
public static boolean arrayEquals(@Nullable float[] array1, @Nullable float[] array2) {
if (array1 == array2) return true;
if (null == array1 || null == array2) return false;
return Arrays.equals(array1, array2);
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable float[] array1, @Nullable int[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable float[] array1, @Nullable long[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable float[] array1, @Nullable short[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable int[] array1, @Nullable boolean[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable int[] array1, @Nullable byte[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable int[] array1, @Nullable char[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable int[] array1, @Nullable double[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable int[] array1, @Nullable float[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; null,!null->false; !null,null->false", pure = true)
public static boolean arrayEquals(@Nullable int[] array1, @Nullable int[] array2) {
if (array1 == array2) return true;
if (null == array1 || null == array2) return false;
return Arrays.equals(array1, array2);
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable int[] array1, @Nullable long[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable int[] array1, @Nullable short[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable long[] array1, @Nullable boolean[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable long[] array1, @Nullable byte[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable long[] array1, @Nullable char[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable long[] array1, @Nullable double[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable long[] array1, @Nullable float[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable long[] array1, @Nullable int[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; null,!null->false; !null,null->false", pure = true)
public static boolean arrayEquals(@Nullable long[] array1, @Nullable long[] array2) {
if (array1 == array2) return true;
if (null == array1 || null == array2) return false;
return Arrays.equals(array1, array2);
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable long[] array1, @Nullable short[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable short[] array1, @Nullable boolean[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable short[] array1, @Nullable byte[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable short[] array1, @Nullable char[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable short[] array1, @Nullable double[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable short[] array1, @Nullable float[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable short[] array1, @Nullable int[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; _,!null->false; !null,_->false", pure = true)
public static boolean arrayEquals(@Nullable short[] array1, @Nullable long[] array2) {
return null == array1 && null == array2;
}
@Contract(value = "null,null->true; null,!null->false; !null,null->false", pure = true)
public static boolean arrayEquals(@Nullable short[] array1, @Nullable short[] array2) {
if (array1 == array2) return true;
if (null == array1 || null == array2) return false;
return Arrays.equals(array1, array2);
}
@Contract(value = "null,null->true; null,!null->false; !null,null->false", pure = true)
public static boolean arrayEquals(@Nullable Object[] array1, @Nullable Object[] array2) {
if (array1 == array2) return true;
if (null == array1 || null == array2) return false;
return Arrays.deepEquals(array1, array2);
}
@Contract(value = "null,null->true; null,!null->false; !null,null->false", pure = true)
public static boolean arrayEquals(@Nullable Object array1, @Nullable Object array2) {
if (array1 == array2) return true;
if (null == array1 || null == array2) return false;
if (array1 instanceof boolean[] && array2 instanceof boolean[]) return Arrays.equals((boolean[]) array1, (boolean[]) array2);
if (array1 instanceof byte[] && array2 instanceof byte[]) return Arrays.equals((byte[]) array1, (byte[]) array2);
if (array1 instanceof char[] && array2 instanceof char[]) return Arrays.equals((char[]) array1, (char[]) array2);
if (array1 instanceof double[] && array2 instanceof double[]) return Arrays.equals((double[]) array1, (double[]) array2);
if (array1 instanceof float[] && array2 instanceof float[]) return Arrays.equals((float[]) array1, (float[]) array2);
if (array1 instanceof int[] && array2 instanceof int[]) return Arrays.equals((int[]) array1, (int[]) array2);
if (array1 instanceof long[] && array2 instanceof long[]) return Arrays.equals((long[]) array1, (long[]) array2);
if (array1 instanceof short[] && array2 instanceof short[]) return Arrays.equals((short[]) array1, (short[]) array2);
if (array1 instanceof Object[] && array2 instanceof Object[]) return Arrays.deepEquals((Object[]) array1, (Object[]) array2);
return array1.equals(array2);
}
@Contract(pure = true)
static int arrayHashCodeArray(@Nullable boolean[] array) {
if (null == array) return 0;
return Arrays.hashCode(array);
}
@Contract(pure = true)
public static int arrayHashCode(@Nullable boolean... array) {
return arrayHashCodeArray(array);
}
@Contract(pure = true)
static int arrayHashCodeArray(@Nullable byte[] array) {
if (null == array) return 0;
return Arrays.hashCode(array);
}
@Contract(pure = true)
public static int arrayHashCode(@Nullable byte... array) {
return arrayHashCodeArray(array);
}
@Contract(pure = true)
static int arrayHashCodeArray(@Nullable char[] array) {
if (null == array) return 0;
return Arrays.hashCode(array);
}
@Contract(pure = true)
public static int arrayHashCode(@Nullable char... array) {
return arrayHashCodeArray(array);
}
@Contract(pure = true)
static int arrayHashCodeArray(@Nullable double[] array) {
if (null == array) return 0;
return Arrays.hashCode(array);
}
@Contract(pure = true)
public static int arrayHashCode(@Nullable double... array) {
return arrayHashCodeArray(array);
}
@Contract(pure = true)
static int arrayHashCodeArray(@Nullable float[] array) {
if (null == array) return 0;
return Arrays.hashCode(array);
}
@Contract(pure = true)
public static int arrayHashCode(@Nullable float... array) {
return arrayHashCodeArray(array);
}
@Contract(pure = true)
static int arrayHashCodeArray(@Nullable int[] array) {
if (null == array) return 0;
return Arrays.hashCode(array);
}
@Contract(pure = true)
public static int arrayHashCode(@Nullable int... array) {
return arrayHashCodeArray(array);
}
@Contract(pure = true)
static int arrayHashCodeArray(@Nullable long[] array) {
if (null == array) return 0;
return Arrays.hashCode(array);
}
@Contract(pure = true)
public static int arrayHashCode(@Nullable long... array) {
return arrayHashCodeArray(array);
}
@Contract(pure = true)
static int arrayHashCodeArray(@Nullable short[] array) {
if (null == array) return 0;
return Arrays.hashCode(array);
}
@Contract(pure = true)
public static int arrayHashCode(@Nullable short... array) {
return arrayHashCodeArray(array);
}
@Contract(pure = true)
static int arrayHashCodeArray(@Nullable Object[] array) {
if (null == array) return 0;
return Arrays.deepHashCode(array);
}
@Contract(pure = true)
public static int arrayHashCode(@Nullable Object... array) {
return arrayHashCodeArray(array);
}
@Contract(pure = true)
public static int arrayHashCode(@Nullable Object array) {
if (null == array) return 0;
if (array instanceof boolean[]) return Arrays.hashCode((boolean[]) array);
if (array instanceof byte[]) return Arrays.hashCode((byte[]) array);
if (array instanceof char[]) return Arrays.hashCode((char[]) array);
if (array instanceof double[]) return Arrays.hashCode((double[]) array);
if (array instanceof float[]) return Arrays.hashCode((float[]) array);
if (array instanceof int[]) return Arrays.hashCode((int[]) array);
if (array instanceof long[]) return Arrays.hashCode((long[]) array);
if (array instanceof short[]) return Arrays.hashCode((short[]) array);
if (array instanceof Object[]) return Arrays.deepHashCode((Object[]) array);
return array.hashCode();
}
@Nonnull
@Contract(pure = true)
static String arrayToStringArray(@Nullable boolean[] array) {
if (null == array) return "null";
return Arrays.toString(array);
}
@Nonnull
@Contract(pure = true)
public static String arrayToString(@Nullable boolean... array) {
return arrayToStringArray(array);
}
@Nonnull
@Contract(pure = true)
static String arrayToStringArray(@Nullable byte[] array) {
if (null == array) return "null";
return Arrays.toString(array);
}
@Nonnull
@Contract(pure = true)
public static String arrayToString(@Nullable byte... array) {
return arrayToStringArray(array);
}
@Nonnull
@Contract(pure = true)
static String arrayToStringArray(@Nullable char[] array) {
if (null == array) return "null";
return Arrays.toString(array);
}
@Nonnull
@Contract(pure = true)
public static String arrayToString(@Nullable char... array) {
return arrayToStringArray(array);
}
@Nonnull
@Contract(pure = true)
static String arrayToStringArray(@Nullable double[] array) {
if (null == array) return "null";
return Arrays.toString(array);
}
@Nonnull
@Contract(pure = true)
public static String arrayToString(@Nullable double... array) {
return arrayToStringArray(array);
}
@Nonnull
@Contract(pure = true)
static String arrayToStringArray(@Nullable float[] array) {
if (null == array) return "null";
return Arrays.toString(array);
}
@Nonnull
@Contract(pure = true)
public static String arrayToString(@Nullable float... array) {
return arrayToStringArray(array);
}
@Nonnull
@Contract(pure = true)
static String arrayToStringArray(@Nullable int[] array) {
if (null == array) return "null";
return Arrays.toString(array);
}
@Nonnull
@Contract(pure = true)
public static String arrayToString(@Nullable int... array) {
return arrayToStringArray(array);
}
@Nonnull
@Contract(pure = true)
static String arrayToStringArray(@Nullable long[] array) {
if (null == array) return "null";
return Arrays.toString(array);
}
@Nonnull
@Contract(pure = true)
public static String arrayToString(@Nullable long... array) {
return arrayToStringArray(array);
}
@Nonnull
@Contract(pure = true)
static String arrayToStringArray(@Nullable short[] array) {
if (null == array) return "null";
return Arrays.toString(array);
}
@Nonnull
@Contract(pure = true)
public static String arrayToString(@Nullable short... array) {
return arrayToStringArray(array);
}
@Nonnull
@Contract(pure = true)
static String arrayToStringArray(@Nullable Object[] array) {
if (null == array) return "null";
return Arrays.deepToString(array);
}
@Nonnull
@Contract(pure = true)
public static String arrayToString(@Nullable Object... array) {
return arrayToStringArray(array);
}
@Nonnull
@Contract(pure = true)
public static String arrayToString(@Nullable Object array) {
if (null == array) return "null";
if (array instanceof boolean[]) return Arrays.toString((boolean[]) array);
if (array instanceof byte[]) return Arrays.toString((byte[]) array);
if (array instanceof char[]) return Arrays.toString((char[]) array);
if (array instanceof double[]) return Arrays.toString((double[]) array);
if (array instanceof float[]) return Arrays.toString((float[]) array);
if (array instanceof int[]) return Arrays.toString((int[]) array);
if (array instanceof long[]) return Arrays.toString((long[]) array);
if (array instanceof short[]) return Arrays.toString((short[]) array);
if (array instanceof Object[]) return Arrays.deepToString((Object[]) array);
return array.toString();
}
@Contract(pure = true)
static boolean startsWithArray(@Nonnull boolean[] array, @Nonnull boolean[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int i = 0; i < other.length; ++i) { if (array[i] != other[i]) return false; }
return true;
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull boolean[] array, @Nonnull boolean... other) {
return startsWithArray(array, other);
}
@Contract(pure = true)
static boolean startsWithArray(@Nonnull byte[] array, @Nonnull byte[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int i = 0; i < other.length; ++i) { if (array[i] != other[i]) return false; }
return true;
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull byte[] array, @Nonnull byte... other) {
return startsWithArray(array, other);
}
@Contract(pure = true)
static boolean startsWithArray(@Nonnull char[] array, @Nonnull char[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int i = 0; i < other.length; ++i) { if (array[i] != other[i]) return false; }
return true;
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull char[] array, @Nonnull char... other) {
return startsWithArray(array, other);
}
@Contract(pure = true)
static boolean startsWithArray(@Nonnull double[] array, @Nonnull double[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int i = 0; i < other.length; ++i) { if (array[i] != other[i]) return false; }
return true;
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull double[] array, @Nonnull double... other) {
return startsWithArray(array, other);
}
@Contract(pure = true)
static boolean startsWithArray(@Nonnull float[] array, @Nonnull float[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int i = 0; i < other.length; ++i) { if (array[i] != other[i]) return false; }
return true;
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull float[] array, @Nonnull float... other) {
return startsWithArray(array, other);
}
@Contract(pure = true)
static boolean startsWithArray(@Nonnull int[] array, @Nonnull int[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int i = 0; i < other.length; ++i) { if (array[i] != other[i]) return false; }
return true;
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull int[] array, @Nonnull int... other) {
return startsWithArray(array, other);
}
@Contract(pure = true)
static boolean startsWithArray(@Nonnull long[] array, @Nonnull long[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int i = 0; i < other.length; ++i) { if (array[i] != other[i]) return false; }
return true;
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull long[] array, @Nonnull long... other) {
return startsWithArray(array, other);
}
@Contract(pure = true)
static boolean startsWithArray(@Nonnull short[] array, @Nonnull short[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int i = 0; i < other.length; ++i) { if (array[i] != other[i]) return false; }
return true;
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull short[] array, @Nonnull short... other) {
return startsWithArray(array, other);
}
@Contract(pure = true)
static boolean startsWithArray(@Nonnull T[] array, @Nonnull O[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int i = 0; i < other.length; ++i) { if (!arrayEquals(array[i], other[i])) return false; }
return true;
}
@SafeVarargs
@Contract(pure = true)
public static boolean startsWith(@Nonnull T[] array, @Nonnull O... other) {
return startsWithArray(array, other);
}
@Contract(pure = true)
static boolean endsWithArray(@Nonnull boolean[] array, @Nonnull boolean[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int n = 1; n <= other.length; ++n) { if (array[array.length - n] != other[other.length - n]) return false; }
return true;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull boolean[] array, @Nonnull boolean... other) {
return endsWithArray(array, other);
}
@Contract(pure = true)
static boolean endsWithArray(@Nonnull byte[] array, @Nonnull byte[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int n = 1; n <= other.length; ++n) { if (array[array.length - n] != other[other.length - n]) return false; }
return true;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull byte[] array, @Nonnull byte... other) {
return endsWithArray(array, other);
}
@Contract(pure = true)
static boolean endsWithArray(@Nonnull char[] array, @Nonnull char[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int n = 1; n <= other.length; ++n) { if (array[array.length - n] != other[other.length - n]) return false; }
return true;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull char[] array, @Nonnull char... other) {
return endsWithArray(array, other);
}
@Contract(pure = true)
static boolean endsWithArray(@Nonnull double[] array, @Nonnull double[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int n = 1; n <= other.length; ++n) { if (array[array.length - n] != other[other.length - n]) return false; }
return true;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull double[] array, @Nonnull double... other) {
return endsWithArray(array, other);
}
@Contract(pure = true)
static boolean endsWithArray(@Nonnull float[] array, @Nonnull float[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int n = 1; n <= other.length; ++n) { if (array[array.length - n] != other[other.length - n]) return false; }
return true;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull float[] array, @Nonnull float... other) {
return endsWithArray(array, other);
}
@Contract(pure = true)
static boolean endsWithArray(@Nonnull int[] array, @Nonnull int[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int n = 1; n <= other.length; ++n) { if (array[array.length - n] != other[other.length - n]) return false; }
return true;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull int[] array, @Nonnull int... other) {
return endsWithArray(array, other);
}
@Contract(pure = true)
static boolean endsWithArray(@Nonnull long[] array, @Nonnull long[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int n = 1; n <= other.length; ++n) { if (array[array.length - n] != other[other.length - n]) return false; }
return true;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull long[] array, @Nonnull long... other) {
return endsWithArray(array, other);
}
@Contract(pure = true)
static boolean endsWithArray(@Nonnull short[] array, @Nonnull short[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int n = 1; n <= other.length; ++n) { if (array[array.length - n] != other[other.length - n]) return false; }
return true;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull short[] array, @Nonnull short... other) {
return endsWithArray(array, other);
}
@Contract(pure = true)
static boolean endsWithArray(@Nonnull T[] array, @Nonnull O[] other) {
if (0 == other.length) return true;
if (array.length < other.length) return false;
for (int n = 1; n <= other.length; ++n) { if (!arrayEquals(array[array.length - n], other[other.length - n])) return false; }
return true;
}
@SafeVarargs
@Contract(pure = true)
public static boolean endsWith(@Nonnull T[] array, @Nonnull O... other) {
return endsWithArray(array, other);
}
@Contract(pure = true)
static int indexOfArray(@Nonnull boolean[] array, @Nonnull boolean[] other) {
if (0 == other.length) return 0;
if (array.length < other.length) return -1;
for (int i = 0; i < array.length - other.length + 1; ++i) {
for (int g = 0; g < other.length; ++g) {
if (array[i] == other[g]) {
if (g == other.length - 1) return i;
} else {
break;
}
}
}
return -1;
}
@Contract(pure = true)
public static int indexOf(@Nonnull boolean[] array, @Nonnull boolean... other) {
return indexOfArray(array, other);
}
@Contract(pure = true)
static int indexOfArray(@Nonnull byte[] array, @Nonnull byte[] other) {
if (0 == other.length) return 0;
if (array.length < other.length) return -1;
for (int i = 0; i < array.length - other.length + 1; ++i) {
for (int g = 0; g < other.length; ++g) {
if (array[i] == other[g]) {
if (g == other.length - 1) return i;
} else {
break;
}
}
}
return -1;
}
@Contract(pure = true)
public static int indexOf(@Nonnull byte[] array, @Nonnull byte... other) {
return indexOfArray(array, other);
}
@Contract(pure = true)
static int indexOfArray(@Nonnull char[] array, @Nonnull char[] other) {
if (0 == other.length) return 0;
if (array.length < other.length) return -1;
for (int i = 0; i < array.length - other.length + 1; ++i) {
for (int g = 0; g < other.length; ++g) {
if (array[i] == other[g]) {
if (g == other.length - 1) return i;
} else {
break;
}
}
}
return -1;
}
@Contract(pure = true)
public static int indexOf(@Nonnull char[] array, @Nonnull char... other) {
return indexOfArray(array, other);
}
@Contract(pure = true)
static int indexOfArray(@Nonnull double[] array, @Nonnull double[] other) {
if (0 == other.length) return 0;
if (array.length < other.length) return -1;
for (int i = 0; i < array.length - other.length + 1; ++i) {
for (int g = 0; g < other.length; ++g) {
if (array[i] == other[g]) {
if (g == other.length - 1) return i;
} else {
break;
}
}
}
return -1;
}
@Contract(pure = true)
public static int indexOf(@Nonnull double[] array, @Nonnull double... other) {
return indexOfArray(array, other);
}
@Contract(pure = true)
static int indexOfArray(@Nonnull float[] array, @Nonnull float[] other) {
if (0 == other.length) return 0;
if (array.length < other.length) return -1;
for (int i = 0; i < array.length - other.length + 1; ++i) {
for (int g = 0; g < other.length; ++g) {
if (array[i] == other[g]) {
if (g == other.length - 1) return i;
} else {
break;
}
}
}
return -1;
}
@Contract(pure = true)
public static int indexOf(@Nonnull float[] array, @Nonnull float... other) {
return indexOfArray(array, other);
}
@Contract(pure = true)
static int indexOfArray(@Nonnull int[] array, @Nonnull int[] other) {
if (0 == other.length) return 0;
if (array.length < other.length) return -1;
for (int i = 0; i < array.length - other.length + 1; ++i) {
for (int g = 0; g < other.length; ++g) {
if (array[i] == other[g]) {
if (g == other.length - 1) return i;
} else {
break;
}
}
}
return -1;
}
@Contract(pure = true)
public static int indexOf(@Nonnull int[] array, @Nonnull int... other) {
return indexOfArray(array, other);
}
@Contract(pure = true)
static int indexOfArray(@Nonnull long[] array, @Nonnull long[] other) {
if (0 == other.length) return 0;
if (array.length < other.length) return -1;
for (int i = 0; i < array.length - other.length + 1; ++i) {
for (int g = 0; g < other.length; ++g) {
if (array[i] == other[g]) {
if (g == other.length - 1) return i;
} else {
break;
}
}
}
return -1;
}
@Contract(pure = true)
public static int indexOf(@Nonnull long[] array, @Nonnull long... other) {
return indexOfArray(array, other);
}
@Contract(pure = true)
static int indexOfArray(@Nonnull short[] array, @Nonnull short[] other) {
if (0 == other.length) return 0;
if (array.length < other.length) return -1;
for (int i = 0; i < array.length - other.length + 1; ++i) {
for (int g = 0; g < other.length; ++g) {
if (array[i] == other[g]) {
if (g == other.length - 1) return i;
} else {
break;
}
}
}
return -1;
}
@Contract(pure = true)
public static int indexOf(@Nonnull short[] array, @Nonnull short... other) {
return indexOfArray(array, other);
}
@Contract(pure = true)
static int indexOfArray(@Nonnull T[] array, @Nonnull O[] other) {
if (0 == other.length) return 0;
if (array.length < other.length) return -1;
for (int i = 0; i < array.length - other.length + 1; ++i) {
for (int g = 0; g < other.length; ++g) {
if (arrayEquals(array[i], other[g])) {
if (g == other.length - 1) return i;
} else {
break;
}
}
}
return -1;
}
@SafeVarargs
@Contract(pure = true)
public static int indexOf(@Nonnull T[] array, @Nonnull O... other) {
return indexOfArray(array, other);
}
@Contract(pure = true)
static boolean containsArray(@Nonnull boolean[] array, @Nonnull boolean[] other) {
return 0 <= indexOfArray(array, other);
}
@Contract(pure = true)
public static boolean contains(@Nonnull boolean[] array, @Nonnull boolean... other) {
return containsArray(array, other);
}
@Contract(pure = true)
static boolean containsArray(@Nonnull byte[] array, @Nonnull byte[] other) {
return 0 <= indexOfArray(array, other);
}
@Contract(pure = true)
public static boolean contains(@Nonnull byte[] array, @Nonnull byte... other) {
return containsArray(array, other);
}
@Contract(pure = true)
static boolean containsArray(@Nonnull char[] array, @Nonnull char[] other) {
return 0 <= indexOfArray(array, other);
}
@Contract(pure = true)
public static boolean contains(@Nonnull char[] array, @Nonnull char... other) {
return containsArray(array, other);
}
@Contract(pure = true)
static boolean containsArray(@Nonnull double[] array, @Nonnull double[] other) {
return 0 <= indexOfArray(array, other);
}
@Contract(pure = true)
public static boolean contains(@Nonnull double[] array, @Nonnull double... other) {
return containsArray(array, other);
}
@Contract(pure = true)
static boolean containsArray(@Nonnull float[] array, @Nonnull float[] other) {
return 0 <= indexOfArray(array, other);
}
@Contract(pure = true)
public static boolean contains(@Nonnull float[] array, @Nonnull float... other) {
return containsArray(array, other);
}
@Contract(pure = true)
static boolean containsArray(@Nonnull int[] array, @Nonnull int[] other) {
return 0 <= indexOfArray(array, other);
}
@Contract(pure = true)
public static boolean contains(@Nonnull int[] array, @Nonnull int... other) {
return containsArray(array, other);
}
@Contract(pure = true)
static boolean containsArray(@Nonnull long[] array, @Nonnull long[] other) {
return 0 <= indexOfArray(array, other);
}
@Contract(pure = true)
public static boolean contains(@Nonnull long[] array, @Nonnull long... other) {
return containsArray(array, other);
}
@Contract(pure = true)
static boolean containsArray(@Nonnull short[] array, @Nonnull short[] other) {
return 0 <= indexOfArray(array, other);
}
@Contract(pure = true)
public static boolean contains(@Nonnull short[] array, @Nonnull short... other) {
return containsArray(array, other);
}
@Contract(pure = true)
static boolean containsArray(@Nonnull T[] array, @Nonnull O[] other) {
return 0 <= indexOfArray(array, other);
}
@SafeVarargs
@Contract(pure = true)
public static boolean contains(@Nonnull T[] array, @Nonnull O... other) {
return containsArray(array, other);
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull boolean[] array, boolean value) {
return 1 <= array.length && array[0] == value;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull boolean[] array, boolean value) {
return 1 <= array.length && array[array.length - 1] == value;
}
@Contract(pure = true)
public static int indexOf(@Nonnull boolean[] array, boolean value) {
for (int i = 0; i < array.length; ++i) {
if (value == array[i]) return i;
}
return -1;
}
@Contract(pure = true)
public static boolean contains(@Nonnull boolean[] array, boolean value) {
return 0 <= indexOf(array, value);
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull byte[] array, byte value) {
return 1 <= array.length && array[0] == value;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull byte[] array, byte value) {
return 1 <= array.length && array[array.length - 1] == value;
}
@Contract(pure = true)
public static int indexOf(@Nonnull byte[] array, byte value) {
for (int i = 0; i < array.length; ++i) {
if (value == array[i]) return i;
}
return -1;
}
@Contract(pure = true)
public static boolean contains(@Nonnull byte[] array, byte value) {
return 0 <= indexOf(array, value);
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull char[] array, char value) {
return 1 <= array.length && array[0] == value;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull char[] array, char value) {
return 1 <= array.length && array[array.length - 1] == value;
}
@Contract(pure = true)
public static int indexOf(@Nonnull char[] array, char value) {
for (int i = 0; i < array.length; ++i) {
if (value == array[i]) return i;
}
return -1;
}
@Contract(pure = true)
public static boolean contains(@Nonnull char[] array, char value) {
return 0 <= indexOf(array, value);
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull double[] array, double value) {
return 1 <= array.length && array[0] == value;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull double[] array, double value) {
return 1 <= array.length && array[array.length - 1] == value;
}
@Contract(pure = true)
public static int indexOf(@Nonnull double[] array, double value) {
for (int i = 0; i < array.length; ++i) {
if (value == array[i]) return i;
}
return -1;
}
@Contract(pure = true)
public static boolean contains(@Nonnull double[] array, double value) {
return 0 <= indexOf(array, value);
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull float[] array, float value) {
return 1 <= array.length && array[0] == value;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull float[] array, float value) {
return 1 <= array.length && array[array.length - 1] == value;
}
@Contract(pure = true)
public static int indexOf(@Nonnull float[] array, float value) {
for (int i = 0; i < array.length; ++i) {
if (value == array[i]) return i;
}
return -1;
}
@Contract(pure = true)
public static boolean contains(@Nonnull float[] array, float value) {
return 0 <= indexOf(array, value);
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull int[] array, int value) {
return 1 <= array.length && array[0] == value;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull int[] array, int value) {
return 1 <= array.length && array[array.length - 1] == value;
}
@Contract(pure = true)
public static int indexOf(@Nonnull int[] array, int value) {
for (int i = 0; i < array.length; ++i) {
if (value == array[i]) return i;
}
return -1;
}
@Contract(pure = true)
public static boolean contains(@Nonnull int[] array, int value) {
return 0 <= indexOf(array, value);
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull long[] array, long value) {
return 1 <= array.length && array[0] == value;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull long[] array, long value) {
return 1 <= array.length && array[array.length - 1] == value;
}
@Contract(pure = true)
public static int indexOf(@Nonnull long[] array, long value) {
for (int i = 0; i < array.length; ++i) {
if (value == array[i]) return i;
}
return -1;
}
@Contract(pure = true)
public static boolean contains(@Nonnull long[] array, long value) {
return 0 <= indexOf(array, value);
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull short[] array, short value) {
return 1 <= array.length && array[0] == value;
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull short[] array, short value) {
return 1 <= array.length && array[array.length - 1] == value;
}
@Contract(pure = true)
public static int indexOf(@Nonnull short[] array, short value) {
for (int i = 0; i < array.length; ++i) {
if (value == array[i]) return i;
}
return -1;
}
@Contract(pure = true)
public static boolean contains(@Nonnull short[] array, short value) {
return 0 <= indexOf(array, value);
}
@Contract(pure = true)
public static boolean startsWith(@Nonnull Object[] array, @Nullable Object value) {
return 1 <= array.length && arrayEquals(array[0], value);
}
@Contract(pure = true)
public static boolean endsWith(@Nonnull Object[] array, @Nullable Object value) {
return 1 <= array.length && arrayEquals(array[array.length - 1], value);
}
@Contract(pure = true)
public static int indexOf(@Nonnull Object[] array, @Nullable Object value) {
for (int i = 0; i < array.length; ++i) {
if (arrayEquals(value, array[i])) return i;
}
return -1;
}
@Contract(pure = true)
public static boolean contains(@Nonnull Object[] array, @Nullable Object value) {
return 0 <= indexOf(array, value);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy