Class ArrayUtil


  • public final class ArrayUtil
    extends Object
    Methods for manipulating arrays.
    NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.
    • Field Summary

      Fields 
      Modifier and Type Field Description
      static int MAX_ARRAY_LENGTH
      Maximum length for an array (Integer.MAX_VALUE - RamUsageEstimator.NUM_BYTES_ARRAY_HEADER).
    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method Description
      static byte[] copyOfSubArray​(byte[] array, int from, int to)
      Copies the specified range of the given array into a new sub array.
      static char[] copyOfSubArray​(char[] array, int from, int to)
      Copies the specified range of the given array into a new sub array.
      static double[] copyOfSubArray​(double[] array, int from, int to)
      Copies the specified range of the given array into a new sub array.
      static float[] copyOfSubArray​(float[] array, int from, int to)
      Copies the specified range of the given array into a new sub array.
      static int[] copyOfSubArray​(int[] array, int from, int to)
      Copies the specified range of the given array into a new sub array.
      static long[] copyOfSubArray​(long[] array, int from, int to)
      Copies the specified range of the given array into a new sub array.
      static short[] copyOfSubArray​(short[] array, int from, int to)
      Copies the specified range of the given array into a new sub array.
      static <T> T[] copyOfSubArray​(T[] array, int from, int to)
      Copies the specified range of the given array into a new sub array.
      static byte[] grow​(byte[] array)
      Returns a larger array, generally over-allocating exponentially
      static byte[] grow​(byte[] array, int minSize)
      Returns an array whose size is at least minSize, generally over-allocating exponentially
      static char[] grow​(char[] array)
      Returns a larger array, generally over-allocating exponentially
      static char[] grow​(char[] array, int minSize)
      Returns an array whose size is at least minSize, generally over-allocating exponentially
      static double[] grow​(double[] array)
      Returns a larger array, generally over-allocating exponentially
      static double[] grow​(double[] array, int minSize)
      Returns an array whose size is at least minSize, generally over-allocating exponentially
      static float[] grow​(float[] array)
      Returns a larger array, generally over-allocating exponentially
      static float[] grow​(float[] array, int minSize)
      Returns an array whose size is at least minSize, generally over-allocating exponentially
      static int[] grow​(int[] array)
      Returns a larger array, generally over-allocating exponentially
      static int[] grow​(int[] array, int minSize)
      Returns an array whose size is at least minSize, generally over-allocating exponentially
      static long[] grow​(long[] array)
      Returns a larger array, generally over-allocating exponentially
      static long[] grow​(long[] array, int minSize)
      Returns an array whose size is at least minSize, generally over-allocating exponentially
      static short[] grow​(short[] array)
      Returns a larger array, generally over-allocating exponentially
      static short[] grow​(short[] array, int minSize)
      Returns an array whose size is at least minSize, generally over-allocating exponentially
      static <T> T[] grow​(T[] array, int minSize)
      Returns an array whose size is at least minSize, generally over-allocating exponentially
      static byte[] growExact​(byte[] array, int newLength)
      Returns a new array whose size is exact the specified newLength without over-allocating
      static char[] growExact​(char[] array, int newLength)
      Returns a new array whose size is exact the specified newLength without over-allocating
      static double[] growExact​(double[] array, int newLength)
      Returns a new array whose size is exact the specified newLength without over-allocating
      static float[] growExact​(float[] array, int newLength)
      Returns a new array whose size is exact the specified newLength without over-allocating
      static int[] growExact​(int[] array, int newLength)
      Returns a new array whose size is exact the specified newLength without over-allocating
      static long[] growExact​(long[] array, int newLength)
      Returns a new array whose size is exact the specified newLength without over-allocating
      static short[] growExact​(short[] array, int newLength)
      Returns a new array whose size is exact the specified newLength without over-allocating
      static <T> T[] growExact​(T[] array, int newLength)
      Returns a new array whose size is exact the specified newLength without over-allocating
      static int hashCode​(char[] array, int start, int end)
      Returns hash of chars in range start (inclusive) to end (inclusive)
      static <T extends Comparable<? super T>>
      void
      introSort​(T[] a)
      Sorts the given array in natural order.
      static <T extends Comparable<? super T>>
      void
      introSort​(T[] a, int fromIndex, int toIndex)
      Sorts the given array slice in natural order.
      static <T> void introSort​(T[] a, int fromIndex, int toIndex, Comparator<? super T> comp)
      Sorts the given array slice using the Comparator.
      static <T> void introSort​(T[] a, Comparator<? super T> comp)
      Sorts the given array using the Comparator.
      static int oversize​(int minTargetSize, int bytesPerElement)
      Returns an array size >= minTargetSize, generally over-allocating exponentially to achieve amortized linear-time cost as the array grows.
      static int parseInt​(char[] chars, int offset, int len)
      Parses a char array into an int.
      static int parseInt​(char[] chars, int offset, int len, int radix)
      Parses the string argument as if it was an int value and returns the result.
      static <T> void select​(T[] arr, int from, int to, int k, Comparator<? super T> comparator)
      Reorganize arr[from:to[ so that the element at offset k is at the same position as if arr[from:to[ was sorted, and all elements on its left are less than or equal to it, and all elements on its right are greater than or equal to it.
      static <T> void swap​(T[] arr, int i, int j)
      Swap values stored in slots i and j
      static <T extends Comparable<? super T>>
      void
      timSort​(T[] a)
      Sorts the given array in natural order.
      static <T extends Comparable<? super T>>
      void
      timSort​(T[] a, int fromIndex, int toIndex)
      Sorts the given array slice in natural order.
      static <T> void timSort​(T[] a, int fromIndex, int toIndex, Comparator<? super T> comp)
      Sorts the given array slice using the Comparator.
      static <T> void timSort​(T[] a, Comparator<? super T> comp)
      Sorts the given array using the Comparator.
    • Field Detail

      • MAX_ARRAY_LENGTH

        public static final int MAX_ARRAY_LENGTH
        Maximum length for an array (Integer.MAX_VALUE - RamUsageEstimator.NUM_BYTES_ARRAY_HEADER).
    • Method Detail

      • parseInt

        public static int parseInt​(char[] chars,
                                   int offset,
                                   int len)
                            throws NumberFormatException
        Parses a char array into an int.
        Parameters:
        chars - the character array
        offset - The offset into the array
        len - The length
        Returns:
        the int
        Throws:
        NumberFormatException - if it can't parse
      • parseInt

        public static int parseInt​(char[] chars,
                                   int offset,
                                   int len,
                                   int radix)
                            throws NumberFormatException
        Parses the string argument as if it was an int value and returns the result. Throws NumberFormatException if the string does not represent an int quantity. The second argument specifies the radix to use when parsing the value.
        Parameters:
        chars - a string representation of an int quantity.
        radix - the base to use for conversion.
        Returns:
        int the value represented by the argument
        Throws:
        NumberFormatException - if the argument could not be parsed as an int quantity.
      • oversize

        public static int oversize​(int minTargetSize,
                                   int bytesPerElement)
        Returns an array size >= minTargetSize, generally over-allocating exponentially to achieve amortized linear-time cost as the array grows. NOTE: this was originally borrowed from Python 2.4.2 listobject.c sources (attribution in LICENSE.txt), but has now been substantially changed based on discussions from java-dev thread with subject "Dynamic array reallocation algorithms", started on Jan 12 2010.
        Parameters:
        minTargetSize - Minimum required value to be returned.
        bytesPerElement - Bytes used by each element of the array. See constants in RamUsageEstimator.
        NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.
      • growExact

        public static <T> T[] growExact​(T[] array,
                                        int newLength)
        Returns a new array whose size is exact the specified newLength without over-allocating
      • grow

        public static <T> T[] grow​(T[] array,
                                   int minSize)
        Returns an array whose size is at least minSize, generally over-allocating exponentially
      • growExact

        public static short[] growExact​(short[] array,
                                        int newLength)
        Returns a new array whose size is exact the specified newLength without over-allocating
      • grow

        public static short[] grow​(short[] array,
                                   int minSize)
        Returns an array whose size is at least minSize, generally over-allocating exponentially
      • grow

        public static short[] grow​(short[] array)
        Returns a larger array, generally over-allocating exponentially
      • growExact

        public static float[] growExact​(float[] array,
                                        int newLength)
        Returns a new array whose size is exact the specified newLength without over-allocating
      • grow

        public static float[] grow​(float[] array,
                                   int minSize)
        Returns an array whose size is at least minSize, generally over-allocating exponentially
      • grow

        public static float[] grow​(float[] array)
        Returns a larger array, generally over-allocating exponentially
      • growExact

        public static double[] growExact​(double[] array,
                                         int newLength)
        Returns a new array whose size is exact the specified newLength without over-allocating
      • grow

        public static double[] grow​(double[] array,
                                    int minSize)
        Returns an array whose size is at least minSize, generally over-allocating exponentially
      • grow

        public static double[] grow​(double[] array)
        Returns a larger array, generally over-allocating exponentially
      • growExact

        public static int[] growExact​(int[] array,
                                      int newLength)
        Returns a new array whose size is exact the specified newLength without over-allocating
      • grow

        public static int[] grow​(int[] array,
                                 int minSize)
        Returns an array whose size is at least minSize, generally over-allocating exponentially
      • grow

        public static int[] grow​(int[] array)
        Returns a larger array, generally over-allocating exponentially
      • growExact

        public static long[] growExact​(long[] array,
                                       int newLength)
        Returns a new array whose size is exact the specified newLength without over-allocating
      • grow

        public static long[] grow​(long[] array,
                                  int minSize)
        Returns an array whose size is at least minSize, generally over-allocating exponentially
      • grow

        public static long[] grow​(long[] array)
        Returns a larger array, generally over-allocating exponentially
      • growExact

        public static byte[] growExact​(byte[] array,
                                       int newLength)
        Returns a new array whose size is exact the specified newLength without over-allocating
      • grow

        public static byte[] grow​(byte[] array,
                                  int minSize)
        Returns an array whose size is at least minSize, generally over-allocating exponentially
      • grow

        public static byte[] grow​(byte[] array)
        Returns a larger array, generally over-allocating exponentially
      • growExact

        public static char[] growExact​(char[] array,
                                       int newLength)
        Returns a new array whose size is exact the specified newLength without over-allocating
      • grow

        public static char[] grow​(char[] array,
                                  int minSize)
        Returns an array whose size is at least minSize, generally over-allocating exponentially
      • grow

        public static char[] grow​(char[] array)
        Returns a larger array, generally over-allocating exponentially
      • hashCode

        public static int hashCode​(char[] array,
                                   int start,
                                   int end)
        Returns hash of chars in range start (inclusive) to end (inclusive)
      • swap

        public static <T> void swap​(T[] arr,
                                    int i,
                                    int j)
        Swap values stored in slots i and j
      • introSort

        public static <T> void introSort​(T[] a,
                                         int fromIndex,
                                         int toIndex,
                                         Comparator<? super T> comp)
        Sorts the given array slice using the Comparator. This method uses the intro sort algorithm, but falls back to insertion sort for small arrays.
        Parameters:
        fromIndex - start index (inclusive)
        toIndex - end index (exclusive)
      • introSort

        public static <T> void introSort​(T[] a,
                                         Comparator<? super T> comp)
        Sorts the given array using the Comparator. This method uses the intro sort algorithm, but falls back to insertion sort for small arrays.
      • introSort

        public static <T extends Comparable<? super T>> void introSort​(T[] a,
                                                                       int fromIndex,
                                                                       int toIndex)
        Sorts the given array slice in natural order. This method uses the intro sort algorithm, but falls back to insertion sort for small arrays.
        Parameters:
        fromIndex - start index (inclusive)
        toIndex - end index (exclusive)
      • introSort

        public static <T extends Comparable<? super T>> void introSort​(T[] a)
        Sorts the given array in natural order. This method uses the intro sort algorithm, but falls back to insertion sort for small arrays.
      • timSort

        public static <T> void timSort​(T[] a,
                                       int fromIndex,
                                       int toIndex,
                                       Comparator<? super T> comp)
        Sorts the given array slice using the Comparator. This method uses the Tim sort algorithm, but falls back to binary sort for small arrays.
        Parameters:
        fromIndex - start index (inclusive)
        toIndex - end index (exclusive)
      • timSort

        public static <T> void timSort​(T[] a,
                                       Comparator<? super T> comp)
        Sorts the given array using the Comparator. This method uses the Tim sort algorithm, but falls back to binary sort for small arrays.
      • timSort

        public static <T extends Comparable<? super T>> void timSort​(T[] a,
                                                                     int fromIndex,
                                                                     int toIndex)
        Sorts the given array slice in natural order. This method uses the Tim sort algorithm, but falls back to binary sort for small arrays.
        Parameters:
        fromIndex - start index (inclusive)
        toIndex - end index (exclusive)
      • timSort

        public static <T extends Comparable<? super T>> void timSort​(T[] a)
        Sorts the given array in natural order. This method uses the Tim sort algorithm, but falls back to binary sort for small arrays.
      • select

        public static <T> void select​(T[] arr,
                                      int from,
                                      int to,
                                      int k,
                                      Comparator<? super T> comparator)
        Reorganize arr[from:to[ so that the element at offset k is at the same position as if arr[from:to[ was sorted, and all elements on its left are less than or equal to it, and all elements on its right are greater than or equal to it. This runs in linear time on average and in n log(n) time in the worst case.
      • copyOfSubArray

        public static byte[] copyOfSubArray​(byte[] array,
                                            int from,
                                            int to)
        Copies the specified range of the given array into a new sub array.
        Parameters:
        array - the input array
        from - the initial index of range to be copied (inclusive)
        to - the final index of range to be copied (exclusive)
      • copyOfSubArray

        public static char[] copyOfSubArray​(char[] array,
                                            int from,
                                            int to)
        Copies the specified range of the given array into a new sub array.
        Parameters:
        array - the input array
        from - the initial index of range to be copied (inclusive)
        to - the final index of range to be copied (exclusive)
      • copyOfSubArray

        public static short[] copyOfSubArray​(short[] array,
                                             int from,
                                             int to)
        Copies the specified range of the given array into a new sub array.
        Parameters:
        array - the input array
        from - the initial index of range to be copied (inclusive)
        to - the final index of range to be copied (exclusive)
      • copyOfSubArray

        public static int[] copyOfSubArray​(int[] array,
                                           int from,
                                           int to)
        Copies the specified range of the given array into a new sub array.
        Parameters:
        array - the input array
        from - the initial index of range to be copied (inclusive)
        to - the final index of range to be copied (exclusive)
      • copyOfSubArray

        public static long[] copyOfSubArray​(long[] array,
                                            int from,
                                            int to)
        Copies the specified range of the given array into a new sub array.
        Parameters:
        array - the input array
        from - the initial index of range to be copied (inclusive)
        to - the final index of range to be copied (exclusive)
      • copyOfSubArray

        public static float[] copyOfSubArray​(float[] array,
                                             int from,
                                             int to)
        Copies the specified range of the given array into a new sub array.
        Parameters:
        array - the input array
        from - the initial index of range to be copied (inclusive)
        to - the final index of range to be copied (exclusive)
      • copyOfSubArray

        public static double[] copyOfSubArray​(double[] array,
                                              int from,
                                              int to)
        Copies the specified range of the given array into a new sub array.
        Parameters:
        array - the input array
        from - the initial index of range to be copied (inclusive)
        to - the final index of range to be copied (exclusive)
      • copyOfSubArray

        public static <T> T[] copyOfSubArray​(T[] array,
                                             int from,
                                             int to)
        Copies the specified range of the given array into a new sub array.
        Parameters:
        array - the input array
        from - the initial index of range to be copied (inclusive)
        to - the final index of range to be copied (exclusive)