Package io.deephaven.base

Class ArrayUtil

java.lang.Object
io.deephaven.base.ArrayUtil
public class ArrayUtil extends Object

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final int
    MAX_ARRAY_SIZE
    The maximum array size is determined by the JVM and in practice is less than Integer.MAX_VALUE.

  • Constructor Summary

    Constructors
    Constructor
    Description
    ArrayUtil()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static <T> T[]
    addExactToArray(T e, T[] a, Class<T> c)
     
    static int[]
    addToArray(int e, int[] a)
     
    static <T> T[]
    addToArray(T e, T[] a, Class<T> c)
     
    static <T, A> T[]
    addUnless(T[] a, Class<T> c, Predicate.Binary<T,A> pred, Function<A,T> factory, A arg)
     
    static <T> T[]
    addUnless(T[] a, Class<T> c, Predicate.Unary<T> pred, Supplier<T> factory)
     
    static boolean
    any(int[] a, Predicate.Int predicate)
     
    static StringBuilder
    appendIntArray(StringBuilder sb, int[] vs, boolean compact)
     
    static boolean
    contains(int[] a, int value)
     
    static boolean
    contains(long[] a, long value)
     
    static <T> boolean
    contains(T[] a, T value)
     
    static <T> boolean
    containsExact(T[] a, T value)
     
    static int[]
    copyArray(int[] a, int L)
     
    static long[]
    copyArray(long[] a, int L)
     
    static double[]
    deleteArrayPos(int i, double[] a)
     
    static int[]
    deleteArrayPos(int i, int[] a)
     
    static <T> T[]
    deleteArrayPos(int i, T[] a)
     
    static <T> T[]
    deleteArrayRefValueIfPresent(T vref, T[] a)
     
    static boolean[]
    ensureSize(boolean[] a, int len)
     
    static boolean[]
    ensureSize(boolean[] a, int len, boolean fill)
     
    static byte[]
    ensureSize(byte[] a, int len)
     
    static byte[]
    ensureSize(byte[] a, int len, byte fill)
     
    static double[]
    ensureSize(double[] a, int len)
     
    static double[]
    ensureSize(double[] a, int len, double fill)
     
    static int[]
    ensureSize(int[] a, int len)
     
    static int[]
    ensureSize(int[] a, int len, int fill)
     
    static long[]
    ensureSize(long[] a, int len)
     
    static long[]
    ensureSize(long[] a, int len, long fill)
     
    static <T> T[]
    ensureSize(T[] a, int len, Class<? extends T> c)
     
    static boolean[]
    ensureSizeNoCopy(boolean[] a, int len)
     
    static byte[]
    ensureSizeNoCopy(byte[] a, int len)
     
    static char[]
    ensureSizeNoCopy(char[] a, int len)
     
    static double[]
    ensureSizeNoCopy(double[] a, int len)
     
    static float[]
    ensureSizeNoCopy(float[] a, int len)
     
    static int[]
    ensureSizeNoCopy(int[] a, int len)
     
    static long[]
    ensureSizeNoCopy(long[] a, int len)
     
    static short[]
    ensureSizeNoCopy(short[] a, int len)
     
    static <T> T[]
    ensureSizeNoCopy(T[] a, int len, Class<? extends T> c)
     
    static boolean
    equals(boolean[] a, boolean[] a2, int start1, int start2, int length)
     
    static boolean
    equals(byte[] a, byte[] a2, int start1, int start2, int length)
     
    static boolean
    equals(char[] a, char[] a2, int start1, int start2, int length)
     
    static boolean
    equals(double[] a, double[] a2, int start1, int start2, int length)
     
    static boolean
    equals(float[] a, float[] a2, int start1, int start2, int length)
     
    static boolean
    equals(int[] a, int[] a2, int start1, int start2, int length)
     
    static boolean
    equals(long[] a, long[] a2, int start1, int start2, int length)
     
    static boolean
    equals(short[] a, short[] a2, int start1, int start2, int length)
     
    static boolean
    equals(Object[] a, Object[] a2, int start1, int start2, int length)
     
    static boolean[]
    extend(boolean[] a, int i)
     
    static boolean[]
    extend(boolean[] a, int i, boolean fill)
     
    static byte[]
    extend(byte[] a, int i)
     
    static byte[]
    extend(byte[] a, int i, byte fill)
     
    static char[]
    extend(char[] a, int i)
     
    static char[]
    extend(char[] a, int i, char fill)
     
    static double[]
    extend(double[] a, int i)
     
    static double[]
    extend(double[] a, int i, double fill)
     
    static float[]
    extend(float[] a, int i)
     
    static float[]
    extend(float[] a, int i, float fill)
     
    static int[]
    extend(int[] a, int i)
     
    static int[]
    extend(int[] a, int i, int fill)
     
    static long[]
    extend(long[] a, int i)
     
    static long[]
    extend(long[] a, int i, long fill)
     
    static short[]
    extend(short[] a, int i)
     
    static short[]
    extend(short[] a, int i, short fill)
     
    static <T> T[]
    extend(T[] a, int i, Class<? extends T> c)
     
    static boolean[]
    extendNoCopy(boolean[] a, int i)
     
    static byte[]
    extendNoCopy(byte[] a, int i)
     
    static char[]
    extendNoCopy(char[] a, int i)
     
    static double[]
    extendNoCopy(double[] a, int i)
     
    static float[]
    extendNoCopy(float[] a, int i)
     
    static int[]
    extendNoCopy(int[] a, int i)
     
    static long[]
    extendNoCopy(long[] a, int i)
     
    static short[]
    extendNoCopy(short[] a, int i)
     
    static <T> T[]
    extendNoCopy(T[] a, int i, Class<? extends T> c)
     
    static int
    find(int[] a, Predicate.Int predicate)
     
    static int
    find(int[] a, Predicate.Int predicate, int notFound)
     
    static <T> T
    find(T[] a, Predicate.Unary<T> predicate)
     
    static int
    hashCode(boolean[] a, int min, int length)
     
    static int
    hashCode(byte[] a, int min, int length)
     
    static int
    hashCode(char[] a, int min, int length)
     
    static int
    hashCode(double[] a, int min, int length)
     
    static int
    hashCode(float[] a, int min, int length)
     
    static int
    hashCode(int[] a, int min, int length)
     
    static int
    hashCode(long[] a, int min, int length)
     
    static int
    hashCode(short[] a, int min, int length)
     
    static int
    hashCode(Object[] a, int min, int length)
     
    static int
    hashCodeAnyOrder(boolean[] a, int min, int length)
     
    static int
    hashCodeAnyOrder(byte[] a, int min, int length)
     
    static int
    hashCodeAnyOrder(char[] a, int min, int length)
     
    static int
    hashCodeAnyOrder(double[] a, int min, int length)
     
    static int
    hashCodeAnyOrder(float[] a, int min, int length)
     
    static int
    hashCodeAnyOrder(int[] a, int min, int length)
     
    static int
    hashCodeAnyOrder(long[] a, int min, int length)
     
    static int
    hashCodeAnyOrder(short[] a, int min, int length)
     
    static int
    hashCodeAnyOrder(Object[] a, int min, int length)
     
    static int
    hashCodeAnyOrderAnySign(double[] a, int min, int length)
     
    static int
    hashCodeAnyOrderAnySign(float[] a, int min, int length)
     
    static int
    hashCodeAnyOrderAnySign(int[] a, int min, int length)
     
    static int
    hashCodeAnyOrderAnySign(long[] a, int min, int length)
     
    static int
    hashCodeAnyOrderAnySign(short[] a, int min, int length)
     
    static int
    indexOf(int[] a, int value)
     
    static <T> int
    indexOf(T[] a, T value)
     
    static <T> void
    init(T[] array, Supplier<T> producer)
     
    static double[]
    insert(double[] a, int i, double v)
     
    static int[]
    insert(int[] a, int i, int v)
     
    static long[]
    insert(long[] a, int i, long v)
     
    static <T> T[]
    insert(T[] a, int insertionPoint, int numElements, T v, Class<? extends T> c)
     
    static <T> T[]
    insert(T[] a, int i, T v, Class<? extends T> c)
     
    static <T> T[]
    insertOrdered(Comparator<T> comp, T[] a, T v, Class<? extends T> c)
     
    static String
    intArrayArrayArrayToString(int[][][] vs)
     
    static String
    intArrayArrayToString(int[][] vs)
     
    static String
    intArrayToString(int[] vs)
     
    static String
    intArrayToString(int[] vs, boolean compact)
     
    static int[]
    intRangeArray(int min, int max)
     
    static boolean
    isSorted(double[] doubles)
     
    static boolean
    isSorted(int[] integers)
     
    static boolean
    isSorted(long[] longs)
     
    static <T extends Comparable<? super T>>
    boolean
    isSorted(T[] objects)
     
    static <K, V> Map<K,V>
    mapFromArray(Class<K> keyType, Class<V> valueType, Object... data)
     
    static int[]
    merge(int[] ss1, int[] ss2)
     
    static <T> T[]
    merge(Class<T> c, T[]... ss)
     
    static <T> T[]
    merge(T[] ss1, T[] ss2, Class<T> c)
     
    static double[]
    pushArray(double e, double[] a)
     
    static int[]
    pushArray(int e, int[] a)
     
    static <T> T[]
    pushArray(T e, T[] a, Class<T> c)
     
    static boolean[]
    put(boolean[] a, int i, boolean v)
     
    static boolean[]
    put(boolean[] a, int i, boolean[] vs, int vi, int vlen)
     
    static byte[]
    put(byte[] a, int i, byte v)
     
    static byte[]
    put(byte[] a, int i, byte[] vs, int vi, int vlen)
     
    static char[]
    put(char[] a, int i, char v)
     
    static char[]
    put(char[] a, int i, char[] vs, int vi, int vlen)
     
    static double[]
    put(double[] a, int i, double v)
     
    static double[]
    put(double[] a, int i, double[] vs, int vi, int vlen)
     
    static float[]
    put(float[] a, int i, float v)
     
    static float[]
    put(float[] a, int i, float[] vs, int vi, int vlen)
     
    static int[]
    put(int[] a, int i, int v)
     
    static int[]
    put(int[] a, int i, int[] vs, int vi, int vlen)
     
    static long[]
    put(long[] a, int i, long v)
     
    static long[]
    put(long[] a, int i, long[] vs, int vi, int vlen)
     
    static short[]
    put(short[] a, int i, short v)
     
    static short[]
    put(short[] a, int i, short[] vs, int vi, int vlen)
     
    static <T> T[]
    put(T[] a, int i, T[] vs, int vi, int vlen, Class<? extends T> c)
     
    static <T> T[]
    put(T[] a, int i, T v, Class<? extends T> c)
     
    static <T> T[]
    removeExactFromArray(T e, T[] a)
     
    static double[]
    removeFromArray(double e, double[] a)
     
    static int[]
    removeFromArray(int e, int[] a)
     
    static <T> T[]
    removeFromArray(T e, T[] a)
     
    static <T, A> T[]
    removeIf(T[] a, Predicate.Binary<T,A> pred, A arg)
     
    static <T, A, B> T[]
    removeIf(T[] a, Predicate.Ternary<T,A,B> pred, A arg1, B arg2)
     
    static <T> T[]
    removeIf(T[] a, Predicate.Unary<T> pred)
     
    static <T> boolean
    replaceInArray(T e, T[] a)
     
    static <T, A> T[]
    replaceOrAdd(T[] a, Class<T> c, Predicate.Binary<T,A> pred, Function<A,T> factory, A arg)
     
    static void
    swap(boolean[] a, int i, int j)
     
    static void
    swap(double[] a, int i, int j)
     
    static void
    swap(int[] a, int i, int j)
     
    static void
    swap(long[] a, int i, int j)
     
    static <T> void
    swap(T[] a, int i, int j)
     
    static String
    toString(double[] doubles, int nOffset, int nLength)
     
    static String
    toString(long[] longs, int nOffset, int nLength)
     

    Methods inherited from class java.lang.Object

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

  • Field Details

    • MAX_ARRAY_SIZE

      public static final int MAX_ARRAY_SIZE
      The maximum array size is determined by the JVM and in practice is less than Integer.MAX_VALUE. (See note at jdk.internal.util.ArraysSupport#SOFT_MAX_ARRAY_LENGTH.)
      See Also:

  • Constructor Details

    • ArrayUtil

      public ArrayUtil()

  • Method Details

    • pushArray

      public static int[] pushArray(int e, int[] a)

    • pushArray

      public static double[] pushArray(double e, double[] a)

    • pushArray

      public static <T> T[] pushArray(T e, T[] a, Class<T> c)

    • deleteArrayPos

      public static <T> T[] deleteArrayPos(int i, T[] a)

    • deleteArrayRefValueIfPresent

      public static <T> T[] deleteArrayRefValueIfPresent(T vref, T[] a)

    • deleteArrayPos

      public static double[] deleteArrayPos(int i, double[] a)

    • deleteArrayPos

      public static int[] deleteArrayPos(int i, int[] a)

    • addToArray

      public static int[] addToArray(int e, int[] a)

    • addToArray

      public static <T> T[] addToArray(T e, T[] a, Class<T> c)

    • addExactToArray

      public static <T> T[] addExactToArray(T e, T[] a, Class<T> c)

    • removeFromArray

      public static <T> T[] removeFromArray(T e, T[] a)

    • removeExactFromArray

      public static <T> T[] removeExactFromArray(T e, T[] a)

    • removeFromArray

      public static int[] removeFromArray(int e, int[] a)

    • removeFromArray

      public static double[] removeFromArray(double e, double[] a)

    • replaceInArray

      public static <T> boolean replaceInArray(T e, T[] a)

    • addUnless

      public static <T> T[] addUnless(T[] a, Class<T> c, Predicate.Unary<T> pred, Supplier<T> factory)

    • addUnless

      public static <T, A> T[] addUnless(T[] a, Class<T> c, Predicate.Binary<T,A> pred, Function<A,T> factory, A arg)

    • replaceOrAdd

      public static <T, A> T[] replaceOrAdd(T[] a, Class<T> c, Predicate.Binary<T,A> pred, Function<A,T> factory, A arg)

    • removeIf

      public static <T> T[] removeIf(T[] a, Predicate.Unary<T> pred)

    • removeIf

      public static <T, A> T[] removeIf(T[] a, Predicate.Binary<T,A> pred, A arg)

    • removeIf

      public static <T, A, B> T[] removeIf(T[] a, Predicate.Ternary<T,A,B> pred, A arg1, B arg2)

    • contains

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

    • containsExact

      public static <T> boolean containsExact(T[] a, T value)

    • contains

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

    • contains

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

    • find

      public static <T> T find(T[] a, Predicate.Unary<T> predicate)

    • find

      public static int find(int[] a, Predicate.Int predicate)

    • find

      public static int find(int[] a, Predicate.Int predicate, int notFound)

    • any

      public static boolean any(int[] a, Predicate.Int predicate)

    • indexOf

      public static <T> int indexOf(T[] a, T value)

    • indexOf

      public static int indexOf(int[] a, int value)

    • extend

      public static <T> T[] extend(T[] a, int i, Class<? extends T> c)

    • merge

      public static int[] merge(int[] ss1, int[] ss2)

    • merge

      public static <T> T[] merge(T[] ss1, T[] ss2, Class<T> c)

    • merge

      public static <T> T[] merge(Class<T> c, T[]... ss)

    • extend

      public static byte[] extend(byte[] a, int i)

    • extend

      public static byte[] extend(byte[] a, int i, byte fill)

    • extend

      public static char[] extend(char[] a, int i)

    • extend

      public static char[] extend(char[] a, int i, char fill)

    • extend

      public static short[] extend(short[] a, int i)

    • extend

      public static short[] extend(short[] a, int i, short fill)

    • extend

      public static int[] extend(int[] a, int i)

    • extend

      public static int[] extend(int[] a, int i, int fill)

    • extend

      public static long[] extend(long[] a, int i)

    • extend

      public static long[] extend(long[] a, int i, long fill)

    • extend

      public static float[] extend(float[] a, int i)

    • extend

      public static float[] extend(float[] a, int i, float fill)

    • extend

      public static double[] extend(double[] a, int i)

    • extend

      public static double[] extend(double[] a, int i, double fill)

    • extend

      public static boolean[] extend(boolean[] a, int i)

    • extend

      public static boolean[] extend(boolean[] a, int i, boolean fill)

    • ensureSize

      public static <T> T[] ensureSize(T[] a, int len, Class<? extends T> c)

    • ensureSize

      public static byte[] ensureSize(byte[] a, int len)

    • ensureSize

      public static byte[] ensureSize(byte[] a, int len, byte fill)

    • ensureSize

      public static int[] ensureSize(int[] a, int len)

    • ensureSize

      public static int[] ensureSize(int[] a, int len, int fill)

    • ensureSize

      public static long[] ensureSize(long[] a, int len)

    • ensureSize

      public static long[] ensureSize(long[] a, int len, long fill)

    • ensureSize

      public static double[] ensureSize(double[] a, int len)

    • ensureSize

      public static double[] ensureSize(double[] a, int len, double fill)

    • ensureSize

      public static boolean[] ensureSize(boolean[] a, int len)

    • ensureSize

      public static boolean[] ensureSize(boolean[] a, int len, boolean fill)

    • extendNoCopy

      public static <T> T[] extendNoCopy(T[] a, int i, Class<? extends T> c)

    • extendNoCopy

      public static char[] extendNoCopy(char[] a, int i)

    • extendNoCopy

      public static short[] extendNoCopy(short[] a, int i)

    • extendNoCopy

      public static int[] extendNoCopy(int[] a, int i)

    • extendNoCopy

      public static long[] extendNoCopy(long[] a, int i)

    • extendNoCopy

      public static float[] extendNoCopy(float[] a, int i)

    • extendNoCopy

      public static double[] extendNoCopy(double[] a, int i)

    • extendNoCopy

      public static boolean[] extendNoCopy(boolean[] a, int i)

    • extendNoCopy

      public static byte[] extendNoCopy(byte[] a, int i)

    • ensureSizeNoCopy

      public static <T> T[] ensureSizeNoCopy(T[] a, int len, Class<? extends T> c)

    • ensureSizeNoCopy

      public static char[] ensureSizeNoCopy(char[] a, int len)

    • ensureSizeNoCopy

      public static short[] ensureSizeNoCopy(short[] a, int len)

    • ensureSizeNoCopy

      public static int[] ensureSizeNoCopy(int[] a, int len)

    • ensureSizeNoCopy

      public static long[] ensureSizeNoCopy(long[] a, int len)

    • ensureSizeNoCopy

      public static float[] ensureSizeNoCopy(float[] a, int len)

    • ensureSizeNoCopy

      public static double[] ensureSizeNoCopy(double[] a, int len)

    • ensureSizeNoCopy

      public static boolean[] ensureSizeNoCopy(boolean[] a, int len)

    • ensureSizeNoCopy

      public static byte[] ensureSizeNoCopy(byte[] a, int len)

    • insert

      public static int[] insert(int[] a, int i, int v)

    • insert

      public static double[] insert(double[] a, int i, double v)

    • insert

      public static long[] insert(long[] a, int i, long v)

    • insert

      public static <T> T[] insert(T[] a, int i, T v, Class<? extends T> c)

    • insert

      public static <T> T[] insert(T[] a, int insertionPoint, int numElements, T v, Class<? extends T> c)

    • insertOrdered

      public static <T> T[] insertOrdered(Comparator<T> comp, T[] a, T v, Class<? extends T> c)

    • put

      public static <T> T[] put(T[] a, int i, T v, Class<? extends T> c)

    • put

      public static <T> T[] put(T[] a, int i, T[] vs, int vi, int vlen, Class<? extends T> c)

    • put

      public static boolean[] put(boolean[] a, int i, boolean[] vs, int vi, int vlen)

    • put

      public static byte[] put(byte[] a, int i, byte[] vs, int vi, int vlen)

    • put

      public static char[] put(char[] a, int i, char[] vs, int vi, int vlen)

    • put

      public static short[] put(short[] a, int i, short[] vs, int vi, int vlen)

    • put

      public static int[] put(int[] a, int i, int[] vs, int vi, int vlen)

    • put

      public static long[] put(long[] a, int i, long[] vs, int vi, int vlen)

    • put

      public static float[] put(float[] a, int i, float[] vs, int vi, int vlen)

    • put

      public static double[] put(double[] a, int i, double[] vs, int vi, int vlen)

    • put

      public static byte[] put(byte[] a, int i, byte v)

    • put

      public static char[] put(char[] a, int i, char v)

    • put

      public static short[] put(short[] a, int i, short v)

    • put

      public static int[] put(int[] a, int i, int v)

    • put

      public static long[] put(long[] a, int i, long v)

    • put

      public static float[] put(float[] a, int i, float v)

    • put

      public static double[] put(double[] a, int i, double v)

    • put

      public static boolean[] put(boolean[] a, int i, boolean v)

    • swap

      public static void swap(int[] a, int i, int j)

    • swap

      public static void swap(long[] a, int i, int j)

    • swap

      public static void swap(double[] a, int i, int j)

    • swap

      public static void swap(boolean[] a, int i, int j)

    • swap

      public static <T> void swap(T[] a, int i, int j)

    • equals

      public static boolean equals(long[] a, long[] a2, int start1, int start2, int length)

    • equals

      public static boolean equals(int[] a, int[] a2, int start1, int start2, int length)

    • equals

      public static boolean equals(short[] a, short[] a2, int start1, int start2, int length)

    • equals

      public static boolean equals(char[] a, char[] a2, int start1, int start2, int length)

    • equals

      public static boolean equals(byte[] a, byte[] a2, int start1, int start2, int length)

    • equals

      public static boolean equals(boolean[] a, boolean[] a2, int start1, int start2, int length)

    • equals

      public static boolean equals(double[] a, double[] a2, int start1, int start2, int length)

    • equals

      public static boolean equals(float[] a, float[] a2, int start1, int start2, int length)

    • equals

      public static boolean equals(Object[] a, Object[] a2, int start1, int start2, int length)

    • hashCode

      public static int hashCode(long[] a, int min, int length)

    • hashCode

      public static int hashCode(int[] a, int min, int length)

    • hashCode

      public static int hashCode(short[] a, int min, int length)

    • hashCode

      public static int hashCode(char[] a, int min, int length)

    • hashCode

      public static int hashCode(byte[] a, int min, int length)

    • hashCode

      public static int hashCode(boolean[] a, int min, int length)

    • hashCode

      public static int hashCode(float[] a, int min, int length)

    • hashCode

      public static int hashCode(double[] a, int min, int length)

    • hashCode

      public static int hashCode(Object[] a, int min, int length)

    • hashCodeAnyOrder

      public static int hashCodeAnyOrder(long[] a, int min, int length)

    • hashCodeAnyOrder

      public static int hashCodeAnyOrder(int[] a, int min, int length)

    • hashCodeAnyOrder

      public static int hashCodeAnyOrder(short[] a, int min, int length)

    • hashCodeAnyOrder

      public static int hashCodeAnyOrder(char[] a, int min, int length)

    • hashCodeAnyOrder

      public static int hashCodeAnyOrder(byte[] a, int min, int length)

    • hashCodeAnyOrder

      public static int hashCodeAnyOrder(boolean[] a, int min, int length)

    • hashCodeAnyOrder

      public static int hashCodeAnyOrder(float[] a, int min, int length)

    • hashCodeAnyOrder

      public static int hashCodeAnyOrder(double[] a, int min, int length)

    • hashCodeAnyOrder

      public static int hashCodeAnyOrder(Object[] a, int min, int length)

    • hashCodeAnyOrderAnySign

      public static int hashCodeAnyOrderAnySign(long[] a, int min, int length)

    • hashCodeAnyOrderAnySign

      public static int hashCodeAnyOrderAnySign(int[] a, int min, int length)

    • hashCodeAnyOrderAnySign

      public static int hashCodeAnyOrderAnySign(short[] a, int min, int length)

    • hashCodeAnyOrderAnySign

      public static int hashCodeAnyOrderAnySign(float[] a, int min, int length)

    • hashCodeAnyOrderAnySign

      public static int hashCodeAnyOrderAnySign(double[] a, int min, int length)

    • mapFromArray

      public static <K, V> Map<K,V> mapFromArray(Class<K> keyType, Class<V> valueType, Object... data)

    • toString

      public static String toString(double[] doubles, int nOffset, int nLength)

    • toString

      public static String toString(long[] longs, int nOffset, int nLength)

    • appendIntArray

      public static StringBuilder appendIntArray(StringBuilder sb, int[] vs, boolean compact)

    • intArrayToString

      public static String intArrayToString(int[] vs)

    • intArrayToString

      public static String intArrayToString(int[] vs, boolean compact)

    • intArrayArrayToString

      public static String intArrayArrayToString(int[][] vs)

    • intArrayArrayArrayToString

      public static String intArrayArrayArrayToString(int[][][] vs)

    • copyArray

      public static int[] copyArray(int[] a, int L)

    • copyArray

      public static long[] copyArray(long[] a, int L)

    • isSorted

      public static boolean isSorted(int[] integers)

    • isSorted

      public static boolean isSorted(long[] longs)

    • isSorted

      public static boolean isSorted(double[] doubles)

    • isSorted

      public static <T extends Comparable<? super T>> boolean isSorted(T[] objects)

    • intRangeArray

      public static int[] intRangeArray(int min, int max)

    • init

      public static <T> void init(T[] array, Supplier<T> producer)