Package one.microstream.collections

Class XArrays

java.lang.Object
one.microstream.collections.XArrays
public final class XArrays
extends Object
Numerous utility methods for working with arrays, all of which are either missing in the JDK or botched up in one way or another. For both writing AND reading code, there must be a LOT of util methods, so that the source code can be as short but comprehensible possible. Keeping the number of util methods at the bare minimum might make things simpler for the JDK provider, but not for the JDK user. There need to be a rich set of proper general purpose tools, not the need to write almost every util method anew in every project.

  • Method Summary

    Modifier and Type Method Description
    static int[] _intAdd​(int[] a1, int... a2)  
    static int[] add​(int[] a1, int... a2)  
    static long[] add​(long[] a1, long... a2)  
    static <T> T[] add​(T[] array, T element)  
    static <T> T[] add​(T[] a1, T... a2)
    Adds all elements of the first array and all elements of the second array into one result array.
    static <T> T[] and​(T[] a1, T[] a2)  
    static <T> boolean applies​(T[] array, Predicate<? super T> predicate)  
    static <D,​ S extends D>
    D[]    		 arraycopy​(S[] src, int srcPos, D[] dest, int destPos, int length)
    Convenience method, calling either System.arraycopy(Object, int, Object, int, int) for length >= 0 or reverseArraycopy(Object[], int, Object[], int, int) for length < 0 and returns dest.
    If length is known to be positive and performance badly matters or negative length shall be treated as an error, use System.arraycopy(Object, int, Object, int, int) directly.
    static int arrayHashCode​(Object[] data, int size)  
    static void checkBounds​(int arrayLength, int start, int bound)  
    static void checkBounds​(Object[] array, int start, int bound)  
    static <T> T[] clear​(T[] array)  
    static <T,​ S extends T>
    T[]    		 combine​(Class<T> componentType, S[]... arrays)  
    static <T> T[] combine​(T[]... arrays)  
    static <E> Class<E> componentType​(E[] array)  
    static boolean contains​(int[] values, int value)  
    static <E> boolean contains​(E[] array, E element)
    This method checks if array contains element by object identity
    static <E> boolean contains​(Collection<? super E> c, E sample, Equalator<? super E> equalator)  
    static <T,​ S extends T>
    boolean    		 contains​(T[] array, S element, Equalator<? super T> cmp)  
    static <E> boolean containS​(Collection<E> c, E element)  
    static <E> boolean containsId​(Collection<E> c, E element)  
    static boolean containsNull​(Object[] data, int offset, int length)  
    static <T> T[] convertArray​(Object[] objects, Class<T> type)  
    static <T> T[] copy​(T[] array)  
    static <E> E[] copyRange​(E[] elements, int offset, int length)  
    static <T,​ E extends T>
    T[]    		 copyTo​(XGettingCollection<E> source, T[] target)
    At least for Java 1.8, the types seem to not be checked.
    static <T,​ E extends T>
    T[]    		 copyTo​(XGettingCollection<E> source, T[] target, int targetOffset)
    At least for Java 1.8, the types seem to not be checked.
    static <T> int count​(T[] array, Predicate<? super T> predicate)  
    static <T> T[] enlarge​(T[] array, int newLength)  
    static <T> T[] ensureContained​(T[] ts, T t)  
    static <T> T[] ensureContained​(T[] a1, T... a2)  
    static <E> boolean eqContains​(E[] array, E element)  
    static boolean equals​(byte[] a, byte[] a2, int length)  
    static <E> boolean equals​(E[] array1, int startIndex1, E[] array2, int startIndex2, int length, Equalator<? super E> comparator)  
    static boolean equals​(Object[] array1, Object[] array2)
    Compares two Object arrays by reference of their content.
    static byte[] fill​(byte[] array, byte fillElement)  
    static char[] fill​(char[] array, char fillElement)  
    static double[] fill​(double[] array, double fillElement)  
    static float[] fill​(float[] array, float fillElement)  
    static int[] fill​(int[] array, int fillElement)  
    static <T> T[] fill​(T[] array, int offset, int bound, Supplier<? extends T> supplier)  
    static <T> T[] fill​(T[] array, Supplier<? extends T> supplier)  
    static <T> T[] fill​(T[] array, T fillElement, int fromIndex, int toIndex)  
    static <E> E[] filter​(E[] elements, Predicate<? super E> predicate)  
    static <E,​ C extends Consumer<? super E>>
    C    		 filterTo​(E[] elements, C target, Predicate<? super E> predicate)  
    static boolean hasNoContent​(Object[] array)
    Returns if the passed array is either null or has the length 0.
    static int indexOf​(boolean value, boolean[] values)  
    static int indexOf​(byte[] data, byte[] subject)  
    static int indexOf​(byte[] data, byte[] subject, int startIndex)  
    static int indexOf​(byte value, byte[] values)  
    static int indexOf​(char value, char[] values)  
    static int indexOf​(double value, double[] values)  
    static int indexOf​(float value, float[] values)  
    static int indexOf​(int value, int[] values)  
    static int indexOf​(long value, long[] values)  
    static int indexOf​(short value, short[] values)  
    static <T,​ S> int indexOf​(S sample, T[] array, BiPredicate<T,​S> predicate)  
    static <T> int indexOf​(T element, T[] array)  
    static void iterate​(int[] elements, int offset, int length, _intProcedure iterator)  
    static void iterate​(int[] elements, _intProcedure iterator)  
    static void iterate​(long[] elements, int offset, int length, _longProcedure iterator)  
    static void iterate​(long[] elements, _longProcedure iterator)  
    static <E> void iterate​(E[] elements, int offset, int length, Consumer<? super E> iterator)  
    static <E,​ I extends Consumer<? super E>>
    I    		 iterate​(E[] elements, I iterator)  
    static int max​(int... data)  
    static <T> T[] merge​(T[] a1, T... a2)
    Merges the both passed arrays by taking all elements from a1 (even duplicates) and adds all elements of a2 (also duplicates as well) that are not already contained in a1.
    static int min​(int... data)  
    static <T> T[] not​(T[] a1, T[] a2)  
    static <T> T[] or​(T[] a1, T[] a2)  
    static <T,​ S extends T>
    T[]    		 orderByIndices​(S[] elements, int[] indices, int indicesOffset, T[] target)
    Orders the passed elements by the passed indices.
    static boolean[] rebuild​(boolean[] oldArray, int newLength)  
    static byte[] rebuild​(byte[] oldArray, int newLength)  
    static char[] rebuild​(char[] oldArray, int newLength)  
    static double[] rebuild​(double[] oldArray, int newLength)  
    static float[] rebuild​(float[] oldArray, int newLength)  
    static int[] rebuild​(int[] oldArray, int newLength)  
    static long[] rebuild​(long[] oldArray, int newLength)  
    static short[] rebuild​(short[] oldArray, int newLength)  
    static <E> E[] rebuild​(E[] oldArray, int newLength)  
    static <T> T[] remove​(T[] array, int i)  
    static int removeAllFromArray​(int[] array, int start, int bound, int e)  
    static <E> int removeAllFromArray​(E[] array, int start, int bound, E e)
    Removed all occurances of e from array array.
    static <E> int removeAllFromArray​(E[] array, int start, int bound, E e, Equalator<? super E> equalator)  
    static <E> int removeAllFromArray​(E[] array, int start, int bound, XGettingCollection<? extends E> elements, Equalator<? super E> equalator)  
    static <E> int removeAllFromArray​(XGettingCollection<? extends E> elements, E[] array, int start, int bound)  
    static <E> E[] removeDuplicates​(E... elements)  
    static <T> T removeFromIndex​(T[] elements, int size, int i)  
    static <E> int replaceAllInArray​(E[] data, int startLow, int boundHigh, E oldElement, E newElement)  
    static <E> int replaceAllInArray​(E[] data, int startLow, int boundHigh, E sample, Equalator<? super E> equalator, E newElement)  
    static <T> T[] replicate​(T subject, int times)  
    static <T> T[] reverse​(T[] array)  
    static int[] reverseArraycopy​(int[] src, int srcPos, int[] dest, int destPos, int length)  
    static <D,​ S extends D>
    D[]    		 reverseArraycopy​(S[] src, int srcPos, D[] dest, int destPos, int length)
    Reverse order counterpart to System.arraycopy(Object, int, Object, int, int).
    static <T> T search​(T[] array, Predicate<? super T> predicate)  
    static void set_booleanInBytes​(byte[] bytes, int index, boolean value)  
    static void set_byteInBytes​(byte[] bytes, int index, byte value)  
    static void set_charInBytes​(byte[] bytes, int index, char value)  
    static void set_doubleInBytes​(byte[] bytes, int index, double value)  
    static void set_floatInBytes​(byte[] bytes, int index, float value)  
    static void set_intInBytes​(byte[] bytes, int index, int value)  
    static void set_longInBytes​(byte[] bytes, int index, long value)  
    static void set_shortInBytes​(byte[] bytes, int index, short value)  
    static <T> T[] shrink​(T[] array, int newLength)  
    static int[] shuffle​(int... data)  
    static long[] shuffle​(long... data)  
    static <E> E[] shuffle​(E[] array, int startIndex, int endIndex)
    Moves the contents of the given array in a random order.
    static int[] shuffle​(FastRandom random, int... data)  
    static long[] shuffle​(FastRandom random, long... data)  
    static <T> T[] shuffle​(T... data)
    Moves the contents of the given array in a random order.
    static int smoothCapacityDecrease​(int oldCapacity)  
    static int smoothCapacityIncrease​(int oldCapacity)  
    static byte[] subArray​(byte[] array, int offset, int length)  
    static char[] subArray​(char[] array, int offset, int length)  
    static <T> T[] subArray​(T[] array, int offset, int length)  
    static <T> T[] toReversed​(T[] array)  
    static <T> T[] toReversed​(T[] array, int offset, int length)  
    static <T> T[] uncheckedFill​(T[] array, int offset, int bound, Supplier<? extends T> supplier)  
    static int validateArrayIndex​(int arrayLength, int index)  
    static int validateArrayRange​(int arrayLength, int offset, int length)  
    static int validateArrayRange​(Object[] array, int offset, int length)  
    static void validateRange0toUpperBound​(int upperBound, int offset, int length)  
    static int validIndex​(int index, Object[] array)  

    Methods inherited from class java.lang.Object

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

  • Method Details

    • validateRange0toUpperBound

      public static final void validateRange0toUpperBound​(int upperBound, int offset, int length)

    • validateArrayIndex

      public static final int validateArrayIndex​(int arrayLength, int index)

    • validIndex

      public static final int validIndex​(int index, Object[] array) throws ArrayIndexOutOfBoundsException
      Throws:
      ArrayIndexOutOfBoundsException

    • validateArrayRange

      public static final int validateArrayRange​(Object[] array, int offset, int length)

    • validateArrayRange

      public static final int validateArrayRange​(int arrayLength, int offset, int length)

    • checkBounds

      public static final void checkBounds​(Object[] array, int start, int bound)

    • checkBounds

      public static final void checkBounds​(int arrayLength, int start, int bound)

    • hasNoContent

      public static boolean hasNoContent​(Object[] array)
      Returns if the passed array is either null or has the length 0.
      Parameters:
      array - the array to check
      Returns:
      true if the passed array has no content

    • fill

      public static final <T> T[] fill​(T[] array, Supplier<? extends T> supplier)

    • fill

      public static final <T> T[] fill​(T[] array, int offset, int bound, Supplier<? extends T> supplier)

    • uncheckedFill

      public static final <T> T[] uncheckedFill​(T[] array, int offset, int bound, Supplier<? extends T> supplier)

    • fill

      public static final <T> T[] fill​(T[] array, T fillElement, int fromIndex, int toIndex)

    • fill

      public static final int[] fill​(int[] array, int fillElement)

    • fill

      public static final char[] fill​(char[] array, char fillElement)

    • fill

      public static final byte[] fill​(byte[] array, byte fillElement)

    • fill

      public static final float[] fill​(float[] array, float fillElement)

    • fill

      public static final double[] fill​(double[] array, double fillElement)

    • clear

      public static final <T> T[] clear​(T[] array)

    • replicate

      public static final <T> T[] replicate​(T subject, int times)

    • subArray

      public static final <T> T[] subArray​(T[] array, int offset, int length)

    • subArray

      public static final byte[] subArray​(byte[] array, int offset, int length)

    • subArray

      public static final char[] subArray​(char[] array, int offset, int length)

    • equals

      public static boolean equals​(Object[] array1, Object[] array2)
      Compares two Object arrays by reference of their content.

      Note that specific equality of each element is situational and thus cannot be a concern of a generic array comparison, just as it cannot be the concern of the element's class directly.

      Parameters:
      array1 - the first array
      array2 - the second array
      Returns:
      true if both arrays are equal

    • equals

      public static final <E> boolean equals​(E[] array1, int startIndex1, E[] array2, int startIndex2, int length, Equalator<? super E> comparator)

    • equals

      public static final boolean equals​(byte[] a, byte[] a2, int length)

    • add

      public static <T> T[] add​(T[] array, T element)

    • remove

      public static <T> T[] remove​(T[] array, int i)

    • add

      @SafeVarargs public static final <T> T[] add​(T[] a1, T... a2)
      Adds all elements of the first array and all elements of the second array into one result array. Handles null-arrays correctly. Always creates a new array instance.
      Type Parameters:
      T - the type of the array elements
      Parameters:
      a1 - the first array
      a2 - the second array
      Returns:
      a new array with the concatenated elements

    • add

      public static final int[] add​(int[] a1, int... a2)

    • add

      public static final long[] add​(long[] a1, long... a2)

    • combine

      @SafeVarargs public static final <T> T[] combine​(T[]... arrays)

    • combine

      public static final <T,​ S extends T> T[] combine​(Class<T> componentType, S[]... arrays)

    • _intAdd

      public static final int[] _intAdd​(int[] a1, int... a2)

    • merge

      @SafeVarargs public static final <T> T[] merge​(T[] a1, T... a2)
      Merges the both passed arrays by taking all elements from a1 (even duplicates) and adds all elements of a2 (also duplicates as well) that are not already contained in a1.
      Type Parameters:
      T - the type of the array elements
      Parameters:
      a1 - the first array
      a2 - the second array
      Returns:
      a new array with the merged elements

    • ensureContained

      @SafeVarargs public static final <T> T[] ensureContained​(T[] a1, T... a2)

    • ensureContained

      public static final <T> T[] ensureContained​(T[] ts, T t)

    • contains

      public static final <E> boolean contains​(E[] array, E element)
      This method checks if array contains element by object identity
      Type Parameters:
      E - any type
      Parameters:
      array - the array to be searched in
      element - the element to be searched (by identity)
      Returns:
      true if array contains element by object identity, else false

    • eqContains

      public static final <E> boolean eqContains​(E[] array, E element)

    • contains

      public static final <T,​ S extends T> boolean contains​(T[] array, S element, Equalator<? super T> cmp)

    • containsId

      public static final <E> boolean containsId​(Collection<E> c, E element)

    • containS

      public static final <E> boolean containS​(Collection<E> c, E element)

    • contains

      public static final <E> boolean contains​(Collection<? super E> c, E sample, Equalator<? super E> equalator)

    • removeAllFromArray

      public static <E> int removeAllFromArray​(E[] array, int start, int bound, E e) throws ArrayIndexOutOfBoundsException
      Removed all occurances of e from array array.
      Type Parameters:
      E - the element type
      Parameters:
      array - the array containing all elements.
      start - the starting offset (inclusive lower bound)
      bound - the bounding offset (exclusive upper bound)
      e - the element to be removed
      Returns:
      the number of removed elements
      Throws:
      ArrayIndexOutOfBoundsException

    • removeAllFromArray

      public static int removeAllFromArray​(int[] array, int start, int bound, int e) throws ArrayIndexOutOfBoundsException
      Throws:
      ArrayIndexOutOfBoundsException

    • removeDuplicates

      @SafeVarargs public static final <E> E[] removeDuplicates​(E... elements)

    • removeAllFromArray

      public static <E> int removeAllFromArray​(XGettingCollection<? extends E> elements, E[] array, int start, int bound) throws ArrayIndexOutOfBoundsException
      Throws:
      ArrayIndexOutOfBoundsException

    • removeAllFromArray

      public static <E> int removeAllFromArray​(E[] array, int start, int bound, E e, Equalator<? super E> equalator) throws ArrayIndexOutOfBoundsException
      Throws:
      ArrayIndexOutOfBoundsException

    • removeAllFromArray

      public static <E> int removeAllFromArray​(E[] array, int start, int bound, XGettingCollection<? extends E> elements, Equalator<? super E> equalator) throws ArrayIndexOutOfBoundsException
      Throws:
      ArrayIndexOutOfBoundsException

    • reverse

      public static final <T> T[] reverse​(T[] array)

    • toReversed

      public static final <T> T[] toReversed​(T[] array)

    • toReversed

      public static final <T> T[] toReversed​(T[] array, int offset, int length)

    • copy

      public static final <T> T[] copy​(T[] array)

    • copyTo

      public static final <T,​ E extends T> T[] copyTo​(XGettingCollection<E> source, T[] target) throws IndexBoundsException
      At least for Java 1.8, the types seem to not be checked. Passing a collection of Strings and a Number[] (meaning String extends Number) is not a compiler error. Bug / generics loophole.
      Type Parameters:
      E - the source element type
      T - the target element type
      Parameters:
      source - the source collection
      target - the target array
      Returns:
      the target array
      Throws:
      IndexBoundsException

    • copyTo

      public static final <T,​ E extends T> T[] copyTo​(XGettingCollection<E> source, T[] target, int targetOffset) throws IndexBoundsException
      At least for Java 1.8, the types seem to not be checked. Passing a collection of Strings and a Number[] (meaning String extends Number) is not a compiler error. Bug / generics loophole.
      Type Parameters:
      E - the source element type
      T - the target element type
      Parameters:
      source - the source collection
      target - the target array
      targetOffset - the target start offset
      Returns:
      the target array
      Throws:
      IndexBoundsException

    • shuffle

      @SafeVarargs public static final <T> T[] shuffle​(T... data)
      Moves the contents of the given array in a random order.
      Type Parameters:
      T - the element type
      Parameters:
      data - the array to shuffle
      Returns:
      the array

    • shuffle

      public static final <E> E[] shuffle​(E[] array, int startIndex, int endIndex)
      Moves the contents of the given array in a random order.
      Type Parameters:
      E - the element type
      Parameters:
      array - the array to shuffle
      startIndex - the start index of the shuffle range
      endIndex - the end index of the shuffle range
      Returns:
      the array

    • shuffle

      public static final int[] shuffle​(int... data)

    • shuffle

      public static final int[] shuffle​(FastRandom random, int... data)

    • shuffle

      public static final long[] shuffle​(long... data)

    • shuffle

      public static final long[] shuffle​(FastRandom random, long... data)

    • arraycopy

      public static <D,​ S extends D> D[] arraycopy​(S[] src, int srcPos, D[] dest, int destPos, int length)
      Convenience method, calling either System.arraycopy(Object, int, Object, int, int) for length >= 0 or reverseArraycopy(Object[], int, Object[], int, int) for length < 0 and returns dest.
      If length is known to be positive and performance badly matters or negative length shall be treated as an error, use System.arraycopy(Object, int, Object, int, int) directly. Otherwise, this method is a convenient alternative to handle more flexible bi-directional array copying.
      Type Parameters:
      D - the destination element type
      S - the source element type
      Parameters:
      src - the source array
      srcPos - the source array position
      dest - the destination array
      destPos - the destination array position
      length - the length of the range to copy
      Returns:
      the destination array

    • enlarge

      public static <T> T[] enlarge​(T[] array, int newLength)

    • shrink

      public static <T> T[] shrink​(T[] array, int newLength)

    • removeFromIndex

      public static <T> T removeFromIndex​(T[] elements, int size, int i)

    • containsNull

      public static final boolean containsNull​(Object[] data, int offset, int length)

    • copyRange

      public static <E> E[] copyRange​(E[] elements, int offset, int length)

    • filter

      public static <E> E[] filter​(E[] elements, Predicate<? super E> predicate)

    • filterTo

      public static <E,​ C extends Consumer<? super E>> C filterTo​(E[] elements, C target, Predicate<? super E> predicate)

    • replaceAllInArray

      public static <E> int replaceAllInArray​(E[] data, int startLow, int boundHigh, E oldElement, E newElement)

    • replaceAllInArray

      public static <E> int replaceAllInArray​(E[] data, int startLow, int boundHigh, E sample, Equalator<? super E> equalator, E newElement)

    • and

      public static <T> T[] and​(T[] a1, T[] a2)

    • or

      public static <T> T[] or​(T[] a1, T[] a2)

    • not

      public static <T> T[] not​(T[] a1, T[] a2)

    • orderByIndices

      public static <T,​ S extends T> T[] orderByIndices​(S[] elements, int[] indices, int indicesOffset, T[] target) throws IllegalArgumentException
      Orders the passed elements by the passed indices.
      Type Parameters:
      T - the target element type
      S - the source element type
      Parameters:
      elements - the elements to be sorted according to the passed indices.
      indices - the indices defining the order in which the passed elements shall be rearranged.
      indicesOffset - the start offset of the indices
      target - the target array to receive the sorted elements.
      Returns:
      the target array
      Throws:
      IllegalArgumentException

    • min

      public static final int min​(int... data)

    • max

      public static final int max​(int... data)

    • applies

      public static final <T> boolean applies​(T[] array, Predicate<? super T> predicate)

    • search

      public static final <T> T search​(T[] array, Predicate<? super T> predicate)

    • count

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

    • reverseArraycopy

      public static <D,​ S extends D> D[] reverseArraycopy​(S[] src, int srcPos, D[] dest, int destPos, int length)
      Reverse order counterpart to System.arraycopy(Object, int, Object, int, int).

      Copies source elements from src, starting at srcPos in negative direction (-length and copies them one by one to dest, starting at destPos in positive direction (+length, thus effectively copying the elements in reverse order.

      Type Parameters:
      S - the source element type
      D - the destination element type
      Parameters:
      src - the source array.
      srcPos - starting position in the source array (the highest index for reverse iteration).
      dest - the destination array.
      destPos - starting position in the destination data (the lowest index in the target array).
      length - the number of array elements to be copied in reverse order.
      Returns:
      the destination array
      Throws:
      ArrayIndexOutOfBoundsException - if copying would cause access of data outside array bounds.
      ArrayStoreException - if an element in the src array could not be stored into the dest array because of a type mismatch.
      NullPointerException - if either src or dest is null.

    • reverseArraycopy

      public static int[] reverseArraycopy​(int[] src, int srcPos, int[] dest, int destPos, int length)

    • convertArray

      public static final <T> T[] convertArray​(Object[] objects, Class<T> type) throws ClassCastException
      Throws:
      ClassCastException

    • componentType

      public static <E> Class<E> componentType​(E[] array)

    • arrayHashCode

      public static final int arrayHashCode​(Object[] data, int size)

    • contains

      public static final boolean contains​(int[] values, int value)

    • iterate

      public static <E,​ I extends Consumer<? super E>> I iterate​(E[] elements, I iterator)

    • iterate

      public static <E> void iterate​(E[] elements, int offset, int length, Consumer<? super E> iterator)

    • iterate

      public static void iterate​(int[] elements, _intProcedure iterator)

    • iterate

      public static void iterate​(int[] elements, int offset, int length, _intProcedure iterator)

    • iterate

      public static void iterate​(long[] elements, _longProcedure iterator)

    • iterate

      public static void iterate​(long[] elements, int offset, int length, _longProcedure iterator)

    • indexOf

      public static final <T,​ S> int indexOf​(S sample, T[] array, BiPredicate<T,​S> predicate)

    • indexOf

      public static final <T> int indexOf​(T element, T[] array)

    • indexOf

      public static final int indexOf​(byte value, byte[] values)

    • indexOf

      public static final int indexOf​(boolean value, boolean[] values)

    • indexOf

      public static final int indexOf​(short value, short[] values)

    • indexOf

      public static final int indexOf​(char value, char[] values)

    • indexOf

      public static final int indexOf​(int value, int[] values)

    • indexOf

      public static final int indexOf​(float value, float[] values)

    • indexOf

      public static final int indexOf​(long value, long[] values)

    • indexOf

      public static final int indexOf​(double value, double[] values)

    • indexOf

      public static final int indexOf​(byte[] data, byte[] subject)

    • indexOf

      public static final int indexOf​(byte[] data, byte[] subject, int startIndex)

    • rebuild

      public static final byte[] rebuild​(byte[] oldArray, int newLength)

    • rebuild

      public static final boolean[] rebuild​(boolean[] oldArray, int newLength)

    • rebuild

      public static final short[] rebuild​(short[] oldArray, int newLength)

    • rebuild

      public static final char[] rebuild​(char[] oldArray, int newLength)

    • rebuild

      public static final int[] rebuild​(int[] oldArray, int newLength)

    • rebuild

      public static final float[] rebuild​(float[] oldArray, int newLength)

    • rebuild

      public static final long[] rebuild​(long[] oldArray, int newLength)

    • rebuild

      public static final double[] rebuild​(double[] oldArray, int newLength)

    • rebuild

      public static final <E> E[] rebuild​(E[] oldArray, int newLength)

    • set_byteInBytes

      public static final void set_byteInBytes​(byte[] bytes, int index, byte value)

    • set_booleanInBytes

      public static final void set_booleanInBytes​(byte[] bytes, int index, boolean value)

    • set_shortInBytes

      public static final void set_shortInBytes​(byte[] bytes, int index, short value)

    • set_charInBytes

      public static final void set_charInBytes​(byte[] bytes, int index, char value)

    • set_intInBytes

      public static final void set_intInBytes​(byte[] bytes, int index, int value)

    • set_floatInBytes

      public static final void set_floatInBytes​(byte[] bytes, int index, float value)

    • set_longInBytes

      public static final void set_longInBytes​(byte[] bytes, int index, long value)

    • set_doubleInBytes

      public static final void set_doubleInBytes​(byte[] bytes, int index, double value)

    • smoothCapacityIncrease

      public static final int smoothCapacityIncrease​(int oldCapacity)

    • smoothCapacityDecrease

      public static final int smoothCapacityDecrease​(int oldCapacity)