# Class Arrays

java.lang.Object
java.util.Arrays

public class Arrays extends Object
`Arrays` contains static methods which operate on arrays.

Since:
  1.2

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static <T> List<T>`
  `asList(T... array)`
  Returns a `List` of the objects in the specified array.
  `static int`
  `binarySearch(byte[] array, byte value)`
  Performs a binary search for the specified element in the specified ascending sorted array.
  `static int`
  `binarySearch(byte[] array, int startIndex, int endIndex, byte value)`
  Performs a binary search for the specified element in a part of the specified sorted array.
  `static int`
  `binarySearch(char[] array, char value)`
  Performs a binary search for the specified element in the specified sorted array.
  `static int`
  `binarySearch(char[] array, int startIndex, int endIndex, char value)`
  Performs a binary search for the specified element in a part of the specified sorted array.
  `static int`
  `binarySearch(double[] array, double value)`
  Performs a binary search for the specified element in the specified sorted array.
  `static int`
  `binarySearch(double[] array, int startIndex, int endIndex, double value)`
  Performs a binary search for the specified element in a part of the specified sorted array.
  `static int`
  `binarySearch(float[] array, float value)`
  Performs a binary search for the specified element in the specified sorted array.
  `static int`
  `binarySearch(float[] array, int startIndex, int endIndex, float value)`
  Performs a binary search for the specified element in a part of the specified sorted array.
  `static int`
  `binarySearch(int[] array, int value)`
  Performs a binary search for the specified element in the specified sorted array.
  `static int`
  `binarySearch(int[] array, int startIndex, int endIndex, int value)`
  Performs a binary search for the specified element in a part of the specified sorted array.
  `static int`
  `binarySearch(long[] array, int startIndex, int endIndex, long value)`
  Performs a binary search for the specified element in a part of the specified sorted array.
  `static int`
  `binarySearch(long[] array, long value)`
  Performs a binary search for the specified element in the specified sorted array.
  `static int`
  `binarySearch(short[] array, int startIndex, int endIndex, short value)`
  Performs a binary search for the specified element in a part of the specified sorted array.
  `static int`
  `binarySearch(short[] array, short value)`
  Performs a binary search for the specified element in the specified sorted array.
  `static int`
  `binarySearch(Object[] array, int startIndex, int endIndex, Object object)`
  Performs a binary search for the specified element in a part of the specified sorted array.
  `static int`
  `binarySearch(Object[] array, Object object)`
  Performs a binary search for the specified element in the specified sorted array.
  `static <T> int`
  `binarySearch(T[] array, int startIndex, int endIndex, T object, Comparator<? super T> comparator)`
  Performs a binary search for the specified element in a part of the specified sorted array using the Comparator to compare elements.
  `static <T> int`
  `binarySearch(T[] array, T object, Comparator<? super T> comparator)`
  Performs a binary search for the specified element in the specified sorted array using the Comparator to compare elements.
  `static boolean[]`
  `copyOf(boolean[] original, int newlen)`
  `static byte[]`
  `copyOf(byte[] original, int newlen)`
  `static char[]`
  `copyOf(char[] original, int newlen)`
  `static double[]`
  `copyOf(double[] original, int newlen)`
  `static float[]`
  `copyOf(float[] original, int newlen)`
  `static int[]`
  `copyOf(int[] original, int newlen)`
  `static long[]`
  `copyOf(long[] original, int newlen)`
  `static short[]`
  `copyOf(short[] original, int len)`
  `static <T> T[]`
  `copyOf(T[] original, int newLength)`
  `static <T> T[]`
  `copyOf(T[] original, int newLength, Class<? extends T[]> newType)`
  `static boolean[]`
  `copyOfRange(boolean[] original, int start, int end)`
  Copies elements in original array to a new array, from index start(inclusive) to end(exclusive).
  `static byte[]`
  `copyOfRange(byte[] original, int start, int end)`
  Copies elements in original array to a new array, from index start(inclusive) to end(exclusive).
  `static char[]`
  `copyOfRange(char[] original, int start, int end)`
  Copies elements in original array to a new array, from index start(inclusive) to end(exclusive).
  `static double[]`
  `copyOfRange(double[] original, int start, int end)`
  Copies elements in original array to a new array, from index start(inclusive) to end(exclusive).
  `static float[]`
  `copyOfRange(float[] original, int start, int end)`
  Copies elements in original array to a new array, from index start(inclusive) to end(exclusive).
  `static int[]`
  `copyOfRange(int[] original, int start, int end)`
  Copies elements in original array to a new array, from index start(inclusive) to end(exclusive).
  `static long[]`
  `copyOfRange(long[] original, int start, int end)`
  Copies elements in original array to a new array, from index start(inclusive) to end(exclusive).
  `static short[]`
  `copyOfRange(short[] original, int start, int end)`
  Copies elements in original array to a new array, from index start(inclusive) to end(exclusive).
  `static <T> T[]`
  `copyOfRange(T[] original, int from, int to)`
  `static <T,U> T[]`
  `copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)`
  `static boolean`
  `deepEquals(Object[] array1, Object[] array2)`
  Returns `true` if the two given arrays are deeply equal to one another.
  `static int`
  `deepHashCode(Object[] array)`
  Returns a hash code based on the "deep contents" of the given array.
  `static String`
  `deepToString(Object[] array)`
  Creates a "deep" `String` representation of the `Object[]` passed, such that if the array contains other arrays, the `String` representation of those arrays is generated as well.
  `static boolean`
  `equals(boolean[] array1, boolean[] array2)`
  Compares the two arrays.
  `static boolean`
  `equals(byte[] array1, byte[] array2)`
  Compares the two arrays.
  `static boolean`
  `equals(char[] array1, char[] array2)`
  Compares the two arrays.
  `static boolean`
  `equals(double[] array1, double[] array2)`
  Compares the two arrays.
  `static boolean`
  `equals(float[] array1, float[] array2)`
  Compares the two arrays.
  `static boolean`
  `equals(int[] array1, int[] array2)`
  Compares the two arrays.
  `static boolean`
  `equals(long[] array1, long[] array2)`
  Compares the two arrays.
  `static boolean`
  `equals(short[] array1, short[] array2)`
  Compares the two arrays.
  `static boolean`
  `equals(Object[] array1, Object[] array2)`
  Compares the two arrays.
  `static void`
  `fill(boolean[] array, boolean value)`
  Fills the specified array with the specified element.
  `static void`
  `fill(boolean[] array, int start, int end, boolean value)`
  Fills the specified range in the array with the specified element.
  `static void`
  `fill(byte[] array, byte value)`
  Fills the specified array with the specified element.
  `static void`
  `fill(byte[] array, int start, int end, byte value)`
  Fills the specified range in the array with the specified element.
  `static void`
  `fill(char[] array, char value)`
  Fills the specified array with the specified element.
  `static void`
  `fill(char[] array, int start, int end, char value)`
  Fills the specified range in the array with the specified element.
  `static void`
  `fill(double[] array, double value)`
  Fills the specified array with the specified element.
  `static void`
  `fill(double[] array, int start, int end, double value)`
  Fills the specified range in the array with the specified element.
  `static void`
  `fill(float[] array, float value)`
  Fills the specified array with the specified element.
  `static void`
  `fill(float[] array, int start, int end, float value)`
  Fills the specified range in the array with the specified element.
  `static void`
  `fill(int[] array, int value)`
  Fills the specified array with the specified element.
  `static void`
  `fill(int[] array, int start, int end, int value)`
  Fills the specified range in the array with the specified element.
  `static void`
  `fill(long[] array, int start, int end, long value)`
  Fills the specified range in the array with the specified element.
  `static void`
  `fill(long[] array, long value)`
  Fills the specified array with the specified element.
  `static void`
  `fill(short[] array, int start, int end, short value)`
  Fills the specified range in the array with the specified element.
  `static void`
  `fill(short[] array, short value)`
  Fills the specified array with the specified element.
  `static void`
  `fill(Object[] array, int start, int end, Object value)`
  Fills the specified range in the array with the specified element.
  `static void`
  `fill(Object[] array, Object value)`
  Fills the specified array with the specified element.
  `static int`
  `hashCode(boolean[] array)`
  Returns a hash code based on the contents of the given array.
  `static int`
  `hashCode(byte[] array)`
  Returns a hash code based on the contents of the given array.
  `static int`
  `hashCode(char[] array)`
  Returns a hash code based on the contents of the given array.
  `static int`
  `hashCode(double[] array)`
  Returns a hash code based on the contents of the given array.
  `static int`
  `hashCode(float[] array)`
  Returns a hash code based on the contents of the given array.
  `static int`
  `hashCode(int[] array)`
  Returns a hash code based on the contents of the given array.
  `static int`
  `hashCode(long[] array)`
  Returns a hash code based on the contents of the given array.
  `static int`
  `hashCode(short[] array)`
  Returns a hash code based on the contents of the given array.
  `static int`
  `hashCode(Object[] array)`
  Returns a hash code based on the contents of the given array.
  `static void`
  `sort(byte[] array)`
  Sorts the specified array in ascending numerical order.
  `static void`
  `sort(byte[] array, int start, int end)`
  Sorts the specified range in the array in ascending numerical order.
  `static void`
  `sort(char[] array)`
  Sorts the specified array in ascending numerical order.
  `static void`
  `sort(char[] array, int start, int end)`
  Sorts the specified range in the array in ascending numerical order.
  `static void`
  `sort(double[] array)`
  Sorts the specified array in ascending numerical order.
  `static void`
  `sort(double[] array, int start, int end)`
  Sorts the specified range in the array in ascending numerical order.
  `static void`
  `sort(float[] array)`
  Sorts the specified array in ascending numerical order.
  `static void`
  `sort(float[] array, int start, int end)`
  Sorts the specified range in the array in ascending numerical order.
  `static void`
  `sort(int[] array)`
  Sorts the specified array in ascending numerical order.
  `static void`
  `sort(int[] array, int start, int end)`
  Sorts the specified range in the array in ascending numerical order.
  `static void`
  `sort(long[] array)`
  Sorts the specified array in ascending numerical order.
  `static void`
  `sort(long[] array, int start, int end)`
  Sorts the specified range in the array in ascending numerical order.
  `static void`
  `sort(short[] array)`
  Sorts the specified array in ascending numerical order.
  `static void`
  `sort(short[] array, int start, int end)`
  Sorts the specified range in the array in ascending numerical order.
  `static void`
  `sort(Object[] array)`
  Sorts the specified array in ascending natural order.
  `static void`
  `sort(Object[] array, int start, int end)`
  Sorts the specified range in the array in ascending natural order.
  `static <T> void`
  `sort(T[] array, int start, int end, Comparator<? super T> comparator)`
  Sorts the specified range in the array using the specified `Comparator`.
  `static <T> void`
  `sort(T[] array, Comparator<? super T> comparator)`
  Sorts the specified array using the specified `Comparator`.
  `static String`
  `toString(boolean[] array)`
  Creates a `String` representation of the `boolean[]` passed.
  `static String`
  `toString(byte[] array)`
  Creates a `String` representation of the `byte[]` passed.
  `static String`
  `toString(char[] array)`
  Creates a `String` representation of the `char[]` passed.
  `static String`
  `toString(double[] array)`
  Creates a `String` representation of the `double[]` passed.
  `static String`
  `toString(float[] array)`
  Creates a `String` representation of the `float[]` passed.
  `static String`
  `toString(int[] array)`
  Creates a `String` representation of the `int[]` passed.
  `static String`
  `toString(long[] array)`
  Creates a `String` representation of the `long[]` passed.
  `static String`
  `toString(short[] array)`
  Creates a `String` representation of the `short[]` passed.
  `static String`
  `toString(Object[] array)`
  Creates a `String` representation of the `Object[]` passed.

  ### Methods inherited from class Object

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

- ## Method Details

  - ### asList

    public static <T> List<T> asList(T... array)
    Returns a `List` of the objects in the specified array. The size of the `List` cannot be modified, i.e. adding and removing are unsupported, but the elements can be set. Setting an element modifies the underlying array.
    Parameters:
      `array` - the array.
    Returns:
      a `List` of the elements of the specified array.

  - ### binarySearch

    public static int binarySearch(byte[] array, byte value)
    Performs a binary search for the specified element in the specified ascending sorted array. Searching in an unsorted array has an undefined result. It's also undefined which element is found if there are multiple occurrences of the same element.
    Parameters:
      `array` - the sorted `byte` array to search.
      `value` - the `byte` element to find.
    Returns:
      the non-negative index of the element, or a negative index which is `-index - 1` where the element would be inserted.

  - ### binarySearch

    public static int binarySearch(char[] array, char value)
    Performs a binary search for the specified element in the specified sorted array.
    Parameters:
      `array` - the sorted char array to search
      `value` - the char element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted

  - ### binarySearch

    public static int binarySearch(double[] array, double value)
    Performs a binary search for the specified element in the specified sorted array.
    Parameters:
      `array` - the sorted double array to search
      `value` - the double element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted

  - ### binarySearch

    public static int binarySearch(float[] array, float value)
    Performs a binary search for the specified element in the specified sorted array.
    Parameters:
      `array` - the sorted float array to search
      `value` - the float element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted

  - ### binarySearch

    public static int binarySearch(int[] array, int value)
    Performs a binary search for the specified element in the specified sorted array.
    Parameters:
      `array` - the sorted int array to search
      `value` - the int element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted

  - ### binarySearch

    public static int binarySearch(long[] array, long value)
    Performs a binary search for the specified element in the specified sorted array.
    Parameters:
      `array` - the sorted long array to search
      `value` - the long element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted

  - ### binarySearch

    public static int binarySearch(Object[] array, Object object)
    Performs a binary search for the specified element in the specified sorted array.
    Parameters:
      `array` - the sorted Object array to search
      `object` - the Object element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted
    Throws:
      `ClassCastException` - when an element in the array or the search element does not implement Comparable, or cannot be compared to each other

  - ### binarySearch

    public static <T> int binarySearch(T[] array, T object, Comparator<? super T> comparator)
    Performs a binary search for the specified element in the specified sorted array using the Comparator to compare elements.
    Type Parameters:
      `T` - type of object
    Parameters:
      `array` - the sorted Object array to search
      `object` - the char element to find
      `comparator` - the Comparator
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted
    Throws:
      `ClassCastException` - when an element in the array and the search element cannot be compared to each other using the Comparator

  - ### binarySearch

    public static int binarySearch(short[] array, short value)
    Performs a binary search for the specified element in the specified sorted array.
    Parameters:
      `array` - the sorted short array to search
      `value` - the short element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted

  - ### binarySearch

    public static int binarySearch(byte[] array, int startIndex, int endIndex, byte value)
    Performs a binary search for the specified element in a part of the specified sorted array.
    Parameters:
      `array` - the sorted byte array to search
      `startIndex` - the inclusive start index
      `endIndex` - the exclusive end index
      `value` - the byte element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted
    Throws:
      `IllegalArgumentException` - - if startIndex is bigger than endIndex
      `ArrayIndexOutOfBoundsException` - - if startIndex is smaller than zero or or endIndex is bigger than length of array
    Since:
      1.6

  - ### binarySearch

    public static int binarySearch(char[] array, int startIndex, int endIndex, char value)
    Performs a binary search for the specified element in a part of the specified sorted array.
    Parameters:
      `array` - the sorted char array to search
      `startIndex` - the inclusive start index
      `endIndex` - the exclusive end index
      `value` - the char element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted
    Throws:
      `IllegalArgumentException` - - if startIndex is bigger than endIndex
      `ArrayIndexOutOfBoundsException` - - if startIndex is smaller than zero or or endIndex is bigger than length of array
    Since:
      1.6

  - ### binarySearch

    public static int binarySearch(double[] array, int startIndex, int endIndex, double value)
    Performs a binary search for the specified element in a part of the specified sorted array.
    Parameters:
      `array` - the sorted double array to search
      `startIndex` - the inclusive start index
      `endIndex` - the exclusive end index
      `value` - the double element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted
    Throws:
      `IllegalArgumentException` - - if startIndex is bigger than endIndex
      `ArrayIndexOutOfBoundsException` - - if startIndex is smaller than zero or or endIndex is bigger than length of array
    Since:
      1.6

  - ### binarySearch

    public static int binarySearch(float[] array, int startIndex, int endIndex, float value)
    Performs a binary search for the specified element in a part of the specified sorted array.
    Parameters:
      `array` - the sorted float array to search
      `startIndex` - the inclusive start index
      `endIndex` - the exclusive end index
      `value` - the float element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted
    Throws:
      `IllegalArgumentException` - - if startIndex is bigger than endIndex
      `ArrayIndexOutOfBoundsException` - - if startIndex is smaller than zero or or endIndex is bigger than length of array
    Since:
      1.6

  - ### binarySearch

    public static int binarySearch(int[] array, int startIndex, int endIndex, int value)
    Performs a binary search for the specified element in a part of the specified sorted array.
    Parameters:
      `array` - the sorted int array to search
      `startIndex` - the inclusive start index
      `endIndex` - the exclusive end index
      `value` - the int element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted
    Throws:
      `IllegalArgumentException` - - if startIndex is bigger than endIndex
      `ArrayIndexOutOfBoundsException` - - if startIndex is smaller than zero or or endIndex is bigger than length of array
    Since:
      1.6

  - ### binarySearch

    public static int binarySearch(long[] array, int startIndex, int endIndex, long value)
    Performs a binary search for the specified element in a part of the specified sorted array.
    Parameters:
      `array` - the sorted long array to search
      `startIndex` - the inclusive start index
      `endIndex` - the exclusive end index
      `value` - the long element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted
    Throws:
      `IllegalArgumentException` - - if startIndex is bigger than endIndex
      `ArrayIndexOutOfBoundsException` - - if startIndex is smaller than zero or or endIndex is bigger than length of array
    Since:
      1.6

  - ### binarySearch

    public static int binarySearch(Object[] array, int startIndex, int endIndex, Object object)
    Performs a binary search for the specified element in a part of the specified sorted array.
    Parameters:
      `array` - the sorted Object array to search
      `startIndex` - the inclusive start index
      `endIndex` - the exclusive end index
      `object` - the object element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted
    Throws:
      `ClassCastException` - when an element in the array or the search element does not implement Comparable, or cannot be compared to each other
      `IllegalArgumentException` - - if startIndex is bigger than endIndex
      `ArrayIndexOutOfBoundsException` - - if startIndex is smaller than zero or or endIndex is bigger than length of array
    Since:
      1.6

  - ### binarySearch

    public static <T> int binarySearch(T[] array, int startIndex, int endIndex, T object, Comparator<? super T> comparator)
    Performs a binary search for the specified element in a part of the specified sorted array using the Comparator to compare elements.
    Type Parameters:
      `T` - type of object
    Parameters:
      `array` - the sorted Object array to search
      `startIndex` - the inclusive start index
      `endIndex` - the exclusive end index
      `object` - the value element to find
      `comparator` - the Comparator
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted
    Throws:
      `ClassCastException` - when an element in the array and the search element cannot be compared to each other using the Comparator
      `IllegalArgumentException` - - if startIndex is bigger than endIndex
      `ArrayIndexOutOfBoundsException` - - if startIndex is smaller than zero or or endIndex is bigger than length of array
    Since:
      1.6

  - ### binarySearch

    public static int binarySearch(short[] array, int startIndex, int endIndex, short value)
    Performs a binary search for the specified element in a part of the specified sorted array.
    Parameters:
      `array` - the sorted short array to search
      `startIndex` - the inclusive start index
      `endIndex` - the exclusive end index
      `value` - the short element to find
    Returns:
      the non-negative index of the element, or a negative index which is the -index - 1 where the element would be inserted
    Throws:
      `IllegalArgumentException` - - if startIndex is bigger than endIndex
      `ArrayIndexOutOfBoundsException` - - if startIndex is smaller than zero or or endIndex is bigger than length of array
    Since:
      1.6

  - ### fill

    public static void fill(byte[] array, byte value)
    Fills the specified array with the specified element.
    Parameters:
      `array` - the `byte` array to fill.
      `value` - the `byte` element.

  - ### fill

    public static void fill(byte[] array, int start, int end, byte value)
    Fills the specified range in the array with the specified element.
    Parameters:
      `array` - the `byte` array to fill.
      `start` - the first index to fill.
      `end` - the last + 1 index to fill.
      `value` - the `byte` element.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### fill

    public static void fill(short[] array, short value)
    Fills the specified array with the specified element.
    Parameters:
      `array` - the `short` array to fill.
      `value` - the `short` element.

  - ### fill

    public static void fill(short[] array, int start, int end, short value)
    Fills the specified range in the array with the specified element.
    Parameters:
      `array` - the `short` array to fill.
      `start` - the first index to fill.
      `end` - the last + 1 index to fill.
      `value` - the `short` element.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### fill

    public static void fill(char[] array, char value)
    Fills the specified array with the specified element.
    Parameters:
      `array` - the `char` array to fill.
      `value` - the `char` element.

  - ### fill

    public static void fill(char[] array, int start, int end, char value)
    Fills the specified range in the array with the specified element.
    Parameters:
      `array` - the `char` array to fill.
      `start` - the first index to fill.
      `end` - the last + 1 index to fill.
      `value` - the `char` element.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### fill

    public static void fill(int[] array, int value)
    Fills the specified array with the specified element.
    Parameters:
      `array` - the `int` array to fill.
      `value` - the `int` element.

  - ### fill

    public static void fill(int[] array, int start, int end, int value)
    Fills the specified range in the array with the specified element.
    Parameters:
      `array` - the `int` array to fill.
      `start` - the first index to fill.
      `end` - the last + 1 index to fill.
      `value` - the `int` element.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### fill

    public static void fill(long[] array, long value)
    Fills the specified array with the specified element.
    Parameters:
      `array` - the `long` array to fill.
      `value` - the `long` element.

  - ### fill

    public static void fill(long[] array, int start, int end, long value)
    Fills the specified range in the array with the specified element.
    Parameters:
      `array` - the `long` array to fill.
      `start` - the first index to fill.
      `end` - the last + 1 index to fill.
      `value` - the `long` element.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### fill

    public static void fill(float[] array, float value)
    Fills the specified array with the specified element.
    Parameters:
      `array` - the `float` array to fill.
      `value` - the `float` element.

  - ### fill

    public static void fill(float[] array, int start, int end, float value)
    Fills the specified range in the array with the specified element.
    Parameters:
      `array` - the `float` array to fill.
      `start` - the first index to fill.
      `end` - the last + 1 index to fill.
      `value` - the `float` element.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### fill

    public static void fill(double[] array, double value)
    Fills the specified array with the specified element.
    Parameters:
      `array` - the `double` array to fill.
      `value` - the `double` element.

  - ### fill

    public static void fill(double[] array, int start, int end, double value)
    Fills the specified range in the array with the specified element.
    Parameters:
      `array` - the `double` array to fill.
      `start` - the first index to fill.
      `end` - the last + 1 index to fill.
      `value` - the `double` element.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### fill

    public static void fill(boolean[] array, boolean value)
    Fills the specified array with the specified element.
    Parameters:
      `array` - the `boolean` array to fill.
      `value` - the `boolean` element.

  - ### fill

    public static void fill(boolean[] array, int start, int end, boolean value)
    Fills the specified range in the array with the specified element.
    Parameters:
      `array` - the `boolean` array to fill.
      `start` - the first index to fill.
      `end` - the last + 1 index to fill.
      `value` - the `boolean` element.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### fill

    public static void fill(Object[] array, Object value)
    Fills the specified array with the specified element.
    Parameters:
      `array` - the `Object` array to fill.
      `value` - the `Object` element.

  - ### fill

    public static void fill(Object[] array, int start, int end, Object value)
    Fills the specified range in the array with the specified element.
    Parameters:
      `array` - the `Object` array to fill.
      `start` - the first index to fill.
      `end` - the last + 1 index to fill.
      `value` - the `Object` element.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### hashCode

    public static int hashCode(boolean[] array)
    Returns a hash code based on the contents of the given array. For any two `boolean` arrays `a` and `b`, if `Arrays.equals(a, b)` returns `true`, it means that the return value of `Arrays.hashCode(a)` equals `Arrays.hashCode(b)`.

    The value returned by this method is the same value as the `List.hashCode()`} method which is invoked on a `List`} containing a sequence of `Boolean`} instances representing the elements of array in the same order. If the array is `null`, the return value is 0.

    Parameters:
      `array` - the array whose hash code to compute.
    Returns:
      the hash code for `array`.

  - ### hashCode

    public static int hashCode(int[] array)
    Returns a hash code based on the contents of the given array. For any two not-null `int` arrays `a` and `b`, if `Arrays.equals(a, b)` returns `true`, it means that the return value of `Arrays.hashCode(a)` equals `Arrays.hashCode(b)`.

    The value returned by this method is the same value as the `List.hashCode()`} method which is invoked on a `List`} containing a sequence of `Integer`} instances representing the elements of array in the same order. If the array is `null`, the return value is 0.

    Parameters:
      `array` - the array whose hash code to compute.
    Returns:
      the hash code for `array`.

  - ### hashCode

    public static int hashCode(short[] array)
    Returns a hash code based on the contents of the given array. For any two `short` arrays `a` and `b`, if `Arrays.equals(a, b)` returns `true`, it means that the return value of `Arrays.hashCode(a)` equals `Arrays.hashCode(b)`.

    The value returned by this method is the same value as the `List.hashCode()`} method which is invoked on a `List`} containing a sequence of `Short`} instances representing the elements of array in the same order. If the array is `null`, the return value is 0.

    Parameters:
      `array` - the array whose hash code to compute.
    Returns:
      the hash code for `array`.

  - ### hashCode

    public static int hashCode(char[] array)
    Returns a hash code based on the contents of the given array. For any two `char` arrays `a` and `b`, if `Arrays.equals(a, b)` returns `true`, it means that the return value of `Arrays.hashCode(a)` equals `Arrays.hashCode(b)`.

    The value returned by this method is the same value as the `List.hashCode()`} method which is invoked on a `List`} containing a sequence of `Character`} instances representing the elements of array in the same order. If the array is `null`, the return value is 0.

    Parameters:
      `array` - the array whose hash code to compute.
    Returns:
      the hash code for `array`.

  - ### hashCode

    public static int hashCode(byte[] array)
    Returns a hash code based on the contents of the given array. For any two `byte` arrays `a` and `b`, if `Arrays.equals(a, b)` returns `true`, it means that the return value of `Arrays.hashCode(a)` equals `Arrays.hashCode(b)`.

    The value returned by this method is the same value as the `List.hashCode()`} method which is invoked on a `List`} containing a sequence of `Byte`} instances representing the elements of array in the same order. If the array is `null`, the return value is 0.

    Parameters:
      `array` - the array whose hash code to compute.
    Returns:
      the hash code for `array`.

  - ### hashCode

    public static int hashCode(long[] array)
    Returns a hash code based on the contents of the given array. For any two `long` arrays `a` and `b`, if `Arrays.equals(a, b)` returns `true`, it means that the return value of `Arrays.hashCode(a)` equals `Arrays.hashCode(b)`.

    The value returned by this method is the same value as the `List.hashCode()`} method which is invoked on a `List`} containing a sequence of `Long`} instances representing the elements of array in the same order. If the array is `null`, the return value is 0.

    Parameters:
      `array` - the array whose hash code to compute.
    Returns:
      the hash code for `array`.

  - ### hashCode

    public static int hashCode(float[] array)
    Returns a hash code based on the contents of the given array. For any two `float` arrays `a` and `b`, if `Arrays.equals(a, b)` returns `true`, it means that the return value of `Arrays.hashCode(a)` equals `Arrays.hashCode(b)`.

    The value returned by this method is the same value as the `List.hashCode()`} method which is invoked on a `List`} containing a sequence of `Float`} instances representing the elements of array in the same order. If the array is `null`, the return value is 0.

    Parameters:
      `array` - the array whose hash code to compute.
    Returns:
      the hash code for `array`.

  - ### hashCode

    public static int hashCode(double[] array)
    Returns a hash code based on the contents of the given array. For any two `double` arrays `a` and `b`, if `Arrays.equals(a, b)` returns `true`, it means that the return value of `Arrays.hashCode(a)` equals `Arrays.hashCode(b)`.

    The value returned by this method is the same value as the `List.hashCode()`} method which is invoked on a `List`} containing a sequence of `Double`} instances representing the elements of array in the same order. If the array is `null`, the return value is 0.

    Parameters:
      `array` - the array whose hash code to compute.
    Returns:
      the hash code for `array`.

  - ### hashCode

    public static int hashCode(Object[] array)
    Returns a hash code based on the contents of the given array. If the array contains other arrays as its elements, the hash code is based on their identities not their contents. So it is acceptable to invoke this method on an array that contains itself as an element, either directly or indirectly.

    For any two arrays `a` and `b`, if `Arrays.equals(a, b)` returns `true`, it means that the return value of `Arrays.hashCode(a)` equals `Arrays.hashCode(b)`.

    The value returned by this method is the same value as the method Arrays.asList(array).hashCode(). If the array is `null`, the return value is 0.

    Parameters:
      `array` - the array whose hash code to compute.
    Returns:
      the hash code for `array`.

  - ### deepHashCode

    public static int deepHashCode(Object[] array)
    Returns a hash code based on the "deep contents" of the given array. If the array contains other arrays as its elements, the hash code is based on their contents not their identities. So it is not acceptable to invoke this method on an array that contains itself as an element, either directly or indirectly.

    For any two arrays `a` and `b`, if `Arrays.deepEquals(a, b)` returns `true`, it means that the return value of `Arrays.deepHashCode(a)` equals `Arrays.deepHashCode(b)`.

    The computation of the value returned by this method is similar to that of the value returned by `List.hashCode()`} invoked on a `List`} containing a sequence of instances representing the elements of array in the same order. The difference is: If an element e of array is itself an array, its hash code is computed by calling the appropriate overloading of `Arrays.hashCode(e)` if e is an array of a primitive type, or by calling `Arrays.deepHashCode(e)` recursively if e is an array of a reference type. The value returned by this method is the same value as the method `Arrays.asList(array).hashCode()`. If the array is `null`, the return value is 0.

    Parameters:
      `array` - the array whose hash code to compute.
    Returns:
      the hash code for `array`.

  - ### equals

    public static boolean equals(byte[] array1, byte[] array2)
    Compares the two arrays.
    Parameters:
      `array1` - the first `byte` array.
      `array2` - the second `byte` array.
    Returns:
      `true` if both arrays are `null` or if the arrays have the same length and the elements at each index in the two arrays are equal, `false` otherwise.

  - ### equals

    public static boolean equals(short[] array1, short[] array2)
    Compares the two arrays.
    Parameters:
      `array1` - the first `short` array.
      `array2` - the second `short` array.
    Returns:
      `true` if both arrays are `null` or if the arrays have the same length and the elements at each index in the two arrays are equal, `false` otherwise.

  - ### equals

    public static boolean equals(char[] array1, char[] array2)
    Compares the two arrays.
    Parameters:
      `array1` - the first `char` array.
      `array2` - the second `char` array.
    Returns:
      `true` if both arrays are `null` or if the arrays have the same length and the elements at each index in the two arrays are equal, `false` otherwise.

  - ### equals

    public static boolean equals(int[] array1, int[] array2)
    Compares the two arrays.
    Parameters:
      `array1` - the first `int` array.
      `array2` - the second `int` array.
    Returns:
      `true` if both arrays are `null` or if the arrays have the same length and the elements at each index in the two arrays are equal, `false` otherwise.

  - ### equals

    public static boolean equals(long[] array1, long[] array2)
    Compares the two arrays.
    Parameters:
      `array1` - the first `long` array.
      `array2` - the second `long` array.
    Returns:
      `true` if both arrays are `null` or if the arrays have the same length and the elements at each index in the two arrays are equal, `false` otherwise.

  - ### equals

    public static boolean equals(float[] array1, float[] array2)
    Compares the two arrays. The values are compared in the same manner as `Float.equals()`.
    Parameters:
      `array1` - the first `float` array.
      `array2` - the second `float` array.
    Returns:
      `true` if both arrays are `null` or if the arrays have the same length and the elements at each index in the two arrays are equal, `false` otherwise.
    See Also:
      - `Float.equals(Object)`

  - ### equals

    public static boolean equals(double[] array1, double[] array2)
    Compares the two arrays. The values are compared in the same manner as `Double.equals()`.
    Parameters:
      `array1` - the first `double` array.
      `array2` - the second `double` array.
    Returns:
      `true` if both arrays are `null` or if the arrays have the same length and the elements at each index in the two arrays are equal, `false` otherwise.
    See Also:
      - `Double.equals(Object)`

  - ### equals

    public static boolean equals(boolean[] array1, boolean[] array2)
    Compares the two arrays.
    Parameters:
      `array1` - the first `boolean` array.
      `array2` - the second `boolean` array.
    Returns:
      `true` if both arrays are `null` or if the arrays have the same length and the elements at each index in the two arrays are equal, `false` otherwise.

  - ### equals

    public static boolean equals(Object[] array1, Object[] array2)
    Compares the two arrays.
    Parameters:
      `array1` - the first `Object` array.
      `array2` - the second `Object` array.
    Returns:
      `true` if both arrays are `null` or if the arrays have the same length and the elements at each index in the two arrays are equal according to `equals()`, `false` otherwise.

  - ### deepEquals

    public static boolean deepEquals(Object[] array1, Object[] array2)
    Returns `true` if the two given arrays are deeply equal to one another. Unlike the method `equals(Object[] array1, Object[] array2)`, this method is appropriate for use for nested arrays of arbitrary depth.

    Two array references are considered deeply equal if they are both `null`, or if they refer to arrays that have the same length and the elements at each index in the two arrays are equal.

    Two `null` elements `element1` and `element2` are possibly deeply equal if any of the following conditions satisfied:

    `element1` and `element2` are both arrays of object reference types, and `Arrays.deepEquals(element1, element2)` would return `true`.

    `element1` and `element2` are arrays of the same primitive type, and the appropriate overloading of `Arrays.equals(element1, element2)` would return `true`.

    `element1 == element2`

    `element1.equals(element2)` would return `true`.

    Note that this definition permits `null` elements at any depth.

    If either of the given arrays contain themselves as elements, the behavior of this method is uncertain.

    Parameters:
      `array1` - the first `Object` array.
      `array2` - the second `Object` array.
    Returns:
      `true` if both arrays are `null` or if the arrays have the same length and the elements at each index in the two arrays are equal according to `equals()`, `false` otherwise.

  - ### sort

    public static void sort(byte[] array)
    Sorts the specified array in ascending numerical order.
    Parameters:
      `array` - the `byte` array to be sorted.

  - ### sort

    public static void sort(byte[] array, int start, int end)
    Sorts the specified range in the array in ascending numerical order.
    Parameters:
      `array` - the `byte` array to be sorted.
      `start` - the start index to sort.
      `end` - the last + 1 index to sort.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### sort

    public static void sort(char[] array)
    Sorts the specified array in ascending numerical order.
    Parameters:
      `array` - the `char` array to be sorted.

  - ### sort

    public static void sort(char[] array, int start, int end)
    Sorts the specified range in the array in ascending numerical order.
    Parameters:
      `array` - the `char` array to be sorted.
      `start` - the start index to sort.
      `end` - the last + 1 index to sort.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### sort

    public static void sort(double[] array)
    Sorts the specified array in ascending numerical order.
    Parameters:
      `array` - the `double` array to be sorted.
    See Also:
      - `sort(double[], int, int)`

  - ### sort

    public static void sort(double[] array, int start, int end)
    Sorts the specified range in the array in ascending numerical order. The values are sorted according to the order imposed by `Double.compareTo()`.
    Parameters:
      `array` - the `double` array to be sorted.
      `start` - the start index to sort.
      `end` - the last + 1 index to sort.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.
    See Also:
      - `Double.compareTo(Double)`

  - ### sort

    public static void sort(float[] array)
    Sorts the specified array in ascending numerical order.
    Parameters:
      `array` - the `float` array to be sorted.
    See Also:
      - `sort(float[], int, int)`

  - ### sort

    public static void sort(float[] array, int start, int end)
    Sorts the specified range in the array in ascending numerical order. The values are sorted according to the order imposed by `Float.compareTo()`.
    Parameters:
      `array` - the `float` array to be sorted.
      `start` - the start index to sort.
      `end` - the last + 1 index to sort.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.
    See Also:
      - `Float.compareTo(Float)`

  - ### sort

    public static void sort(int[] array)
    Sorts the specified array in ascending numerical order.
    Parameters:
      `array` - the `int` array to be sorted.

  - ### sort

    public static void sort(int[] array, int start, int end)
    Sorts the specified range in the array in ascending numerical order.
    Parameters:
      `array` - the `int` array to be sorted.
      `start` - the start index to sort.
      `end` - the last + 1 index to sort.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### sort

    public static void sort(long[] array)
    Sorts the specified array in ascending numerical order.
    Parameters:
      `array` - the `long` array to be sorted.

  - ### sort

    public static void sort(long[] array, int start, int end)
    Sorts the specified range in the array in ascending numerical order.
    Parameters:
      `array` - the `long` array to be sorted.
      `start` - the start index to sort.
      `end` - the last + 1 index to sort.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### sort

    public static void sort(Object[] array)
    Sorts the specified array in ascending natural order.
    Parameters:
      `array` - the `Object` array to be sorted.
    Throws:
      `ClassCastException` - if an element in the array does not implement `Comparable` or if some elements cannot be compared to each other.
    See Also:
      - `sort(Object[], int, int)`

  - ### sort

    public static void sort(Object[] array, int start, int end)
    Sorts the specified range in the array in ascending natural order. All elements must implement the `Comparable` interface and must be comparable to each other without a `ClassCastException` being thrown.
    Parameters:
      `array` - the `Object` array to be sorted.
      `start` - the start index to sort.
      `end` - the last + 1 index to sort.
    Throws:
      `ClassCastException` - if an element in the array does not implement `Comparable` or some elements cannot be compared to each other.
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### sort

    public static <T> void sort(T[] array, int start, int end, Comparator<? super T> comparator)
    Sorts the specified range in the array using the specified `Comparator`. All elements must be comparable to each other without a `ClassCastException` being thrown.
    Parameters:
      `array` - the `Object` array to be sorted.
      `start` - the start index to sort.
      `end` - the last + 1 index to sort.
      `comparator` - the `Comparator`.
    Throws:
      `ClassCastException` - if elements in the array cannot be compared to each other using the `Comparator`.
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### sort

    public static <T> void sort(T[] array, Comparator<? super T> comparator)
    Sorts the specified array using the specified `Comparator`. All elements must be comparable to each other without a `ClassCastException` being thrown.
    Parameters:
      `array` - the `Object` array to be sorted.
      `comparator` - the `Comparator`.
    Throws:
      `ClassCastException` - if elements in the array cannot be compared to each other using the `Comparator`.

  - ### sort

    public static void sort(short[] array)
    Sorts the specified array in ascending numerical order.
    Parameters:
      `array` - the `short` array to be sorted.

  - ### sort

    public static void sort(short[] array, int start, int end)
    Sorts the specified range in the array in ascending numerical order.
    Parameters:
      `array` - the `short` array to be sorted.
      `start` - the start index to sort.
      `end` - the last + 1 index to sort.
    Throws:
      `IllegalArgumentException` - if `start > end`.
      `ArrayIndexOutOfBoundsException` - if `start < 0` or `end > array.length`.

  - ### toString

    public static String toString(boolean[] array)
    Creates a `String` representation of the `boolean[]` passed. The result is surrounded by brackets (`&quot;[]&quot;`), each element is converted to a `String` via the `String.valueOf(boolean)` and separated by `&quot;, &quot;`. If the array is `null`, then `&quot;null&quot;` is returned.
    Parameters:
      `array` - the `boolean` array to convert.
    Returns:
      the `String` representation of `array`.
    Since:
      1.5

  - ### toString

    public static String toString(byte[] array)
    Creates a `String` representation of the `byte[]` passed. The result is surrounded by brackets (`&quot;[]&quot;`), each element is converted to a `String` via the `String.valueOf(int)` and separated by `&quot;, &quot;`. If the array is `null`, then `&quot;null&quot;` is returned.
    Parameters:
      `array` - the `byte` array to convert.
    Returns:
      the `String` representation of `array`.
    Since:
      1.5

  - ### toString

    public static String toString(char[] array)
    Creates a `String` representation of the `char[]` passed. The result is surrounded by brackets (`&quot;[]&quot;`), each element is converted to a `String` via the `String.valueOf(char)` and separated by `&quot;, &quot;`. If the array is `null`, then `&quot;null&quot;` is returned.
    Parameters:
      `array` - the `char` array to convert.
    Returns:
      the `String` representation of `array`.
    Since:
      1.5

  - ### toString

    public static String toString(double[] array)
    Creates a `String` representation of the `double[]` passed. The result is surrounded by brackets (`&quot;[]&quot;`), each element is converted to a `String` via the `String.valueOf(double)` and separated by `&quot;, &quot;`. If the array is `null`, then `&quot;null&quot;` is returned.
    Parameters:
      `array` - the `double` array to convert.
    Returns:
      the `String` representation of `array`.
    Since:
      1.5

  - ### toString

    public static String toString(float[] array)
    Creates a `String` representation of the `float[]` passed. The result is surrounded by brackets (`&quot;[]&quot;`), each element is converted to a `String` via the `String.valueOf(float)` and separated by `&quot;, &quot;`. If the array is `null`, then `&quot;null&quot;` is returned.
    Parameters:
      `array` - the `float` array to convert.
    Returns:
      the `String` representation of `array`.
    Since:
      1.5

  - ### toString

    public static String toString(int[] array)
    Creates a `String` representation of the `int[]` passed. The result is surrounded by brackets (`&quot;[]&quot;`), each element is converted to a `String` via the `String.valueOf(int)` and separated by `&quot;, &quot;`. If the array is `null`, then `&quot;null&quot;` is returned.
    Parameters:
      `array` - the `int` array to convert.
    Returns:
      the `String` representation of `array`.
    Since:
      1.5

  - ### toString

    public static String toString(long[] array)
    Creates a `String` representation of the `long[]` passed. The result is surrounded by brackets (`&quot;[]&quot;`), each element is converted to a `String` via the `String.valueOf(long)` and separated by `&quot;, &quot;`. If the array is `null`, then `&quot;null&quot;` is returned.
    Parameters:
      `array` - the `long` array to convert.
    Returns:
      the `String` representation of `array`.
    Since:
      1.5

  - ### toString

    public static String toString(short[] array)
    Creates a `String` representation of the `short[]` passed. The result is surrounded by brackets (`&quot;[]&quot;`), each element is converted to a `String` via the `String.valueOf(int)` and separated by `&quot;, &quot;`. If the array is `null`, then `&quot;null&quot;` is returned.
    Parameters:
      `array` - the `short` array to convert.
    Returns:
      the `String` representation of `array`.
    Since:
      1.5

  - ### toString

    public static String toString(Object[] array)
    Creates a `String` representation of the `Object[]` passed. The result is surrounded by brackets (`&quot;[]&quot;`), each element is converted to a `String` via the `String.valueOf(Object)` and separated by `&quot;, &quot;`. If the array is `null`, then `&quot;null&quot;` is returned.
    Parameters:
      `array` - the `Object` array to convert.
    Returns:
      the `String` representation of `array`.
    Since:
      1.5

  - ### deepToString

    public static String deepToString(Object[] array)
    Creates a "deep" `String` representation of the `Object[]` passed, such that if the array contains other arrays, the `String` representation of those arrays is generated as well.

    If any of the elements are primitive arrays, the generation is delegated to the other `toString` methods in this class. If any element contains a reference to the original array, then it will be represented as `"[...]"`. If an element is an `Object[]`, then its representation is generated by a recursive call to this method. All other elements are converted via the `String.valueOf(Object)` method.

    Parameters:
      `array` - the `Object` array to convert.
    Returns:
      the `String` representation of `array`.
    Since:
      1.5

  - ### copyOfRange

    public static boolean[] copyOfRange(boolean[] original, int start, int end)
    Copies elements in original array to a new array, from index start(inclusive) to end(exclusive). The first element (if any) in the new array is original[from], and other elements in the new array are in the original order. The padding value whose index is bigger than or equal to original.length - start is false.
    Parameters:
      `original` - the original array
      `start` - the start index, inclusive
      `end` - the end index, exclusive, may bigger than length of the array
    Returns:
      the new copied array
    Throws:
      `ArrayIndexOutOfBoundsException` - if start is smaller than 0 or bigger than original.length
      `IllegalArgumentException` - if start is bigger than end
      `NullPointerException` - if original is null
    Since:
      1.6

  - ### copyOfRange

    public static byte[] copyOfRange(byte[] original, int start, int end)
    Copies elements in original array to a new array, from index start(inclusive) to end(exclusive). The first element (if any) in the new array is original[from], and other elements in the new array are in the original order. The padding value whose index is bigger than or equal to original.length - start is (byte)0.
    Parameters:
      `original` - the original array
      `start` - the start index, inclusive
      `end` - the end index, exclusive, may bigger than length of the array
    Returns:
      the new copied array
    Throws:
      `ArrayIndexOutOfBoundsException` - if start is smaller than 0 or bigger than original.length
      `IllegalArgumentException` - if start is bigger than end
      `NullPointerException` - if original is null
    Since:
      1.6

  - ### copyOfRange

    public static char[] copyOfRange(char[] original, int start, int end)
    Copies elements in original array to a new array, from index start(inclusive) to end(exclusive). The first element (if any) in the new array is original[from], and other elements in the new array are in the original order. The padding value whose index is bigger than or equal to original.length - start is '\\u000'.
    Parameters:
      `original` - the original array
      `start` - the start index, inclusive
      `end` - the end index, exclusive, may bigger than length of the array
    Returns:
      the new copied array
    Throws:
      `ArrayIndexOutOfBoundsException` - if start is smaller than 0 or bigger than original.length
      `IllegalArgumentException` - if start is bigger than end
      `NullPointerException` - if original is null
    Since:
      1.6

  - ### copyOfRange

    public static double[] copyOfRange(double[] original, int start, int end)
    Copies elements in original array to a new array, from index start(inclusive) to end(exclusive). The first element (if any) in the new array is original[from], and other elements in the new array are in the original order. The padding value whose index is bigger than or equal to original.length - start is 0d.
    Parameters:
      `original` - the original array
      `start` - the start index, inclusive
      `end` - the end index, exclusive, may bigger than length of the array
    Returns:
      the new copied array
    Throws:
      `ArrayIndexOutOfBoundsException` - if start is smaller than 0 or bigger than original.length
      `IllegalArgumentException` - if start is bigger than end
      `NullPointerException` - if original is null
    Since:
      1.6

  - ### copyOfRange

    public static float[] copyOfRange(float[] original, int start, int end)
    Copies elements in original array to a new array, from index start(inclusive) to end(exclusive). The first element (if any) in the new array is original[from], and other elements in the new array are in the original order. The padding value whose index is bigger than or equal to original.length - start is 0f.
    Parameters:
      `original` - the original array
      `start` - the start index, inclusive
      `end` - the end index, exclusive, may bigger than length of the array
    Returns:
      the new copied array
    Throws:
      `ArrayIndexOutOfBoundsException` - if start is smaller than 0 or bigger than original.length
      `IllegalArgumentException` - if start is bigger than end
      `NullPointerException` - if original is null
    Since:
      1.6

  - ### copyOfRange

    public static int[] copyOfRange(int[] original, int start, int end)
    Copies elements in original array to a new array, from index start(inclusive) to end(exclusive). The first element (if any) in the new array is original[from], and other elements in the new array are in the original order. The padding value whose index is bigger than or equal to original.length - start is 0.
    Parameters:
      `original` - the original array
      `start` - the start index, inclusive
      `end` - the end index, exclusive, may bigger than length of the array
    Returns:
      the new copied array
    Throws:
      `ArrayIndexOutOfBoundsException` - if start is smaller than 0 or bigger than original.length
      `IllegalArgumentException` - if start is bigger than end
      `NullPointerException` - if original is null
    Since:
      1.6

  - ### copyOfRange

    public static long[] copyOfRange(long[] original, int start, int end)
    Copies elements in original array to a new array, from index start(inclusive) to end(exclusive). The first element (if any) in the new array is original[from], and other elements in the new array are in the original order. The padding value whose index is bigger than or equal to original.length - start is 0L.
    Parameters:
      `original` - the original array
      `start` - the start index, inclusive
      `end` - the end index, exclusive, may bigger than length of the array
    Returns:
      the new copied array
    Throws:
      `ArrayIndexOutOfBoundsException` - if start is smaller than 0 or bigger than original.length
      `IllegalArgumentException` - if start is bigger than end
      `NullPointerException` - if original is null
    Since:
      1.6

  - ### copyOfRange

    public static short[] copyOfRange(short[] original, int start, int end)
    Copies elements in original array to a new array, from index start(inclusive) to end(exclusive). The first element (if any) in the new array is original[from], and other elements in the new array are in the original order. The padding value whose index is bigger than or equal to original.length - start is (short)0.
    Parameters:
      `original` - the original array
      `start` - the start index, inclusive
      `end` - the end index, exclusive, may bigger than length of the array
    Returns:
      the new copied array
    Throws:
      `ArrayIndexOutOfBoundsException` - if start is smaller than 0 or bigger than original.length
      `IllegalArgumentException` - if start is bigger than end
      `NullPointerException` - if original is null
    Since:
      1.6

  - ### copyOfRange

    public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)

  - ### copyOfRange

    public static <T> T[] copyOfRange(T[] original, int from, int to)

  - ### copyOf

    public static <T> T[] copyOf(T[] original, int newLength, Class<? extends T[]> newType)

  - ### copyOf

    public static <T> T[] copyOf(T[] original, int newLength)

  - ### copyOf

    public static boolean[] copyOf(boolean[] original, int newlen)

  - ### copyOf

    public static char[] copyOf(char[] original, int newlen)

  - ### copyOf

    public static double[] copyOf(double[] original, int newlen)

  - ### copyOf

    public static float[] copyOf(float[] original, int newlen)

  - ### copyOf

    public static long[] copyOf(long[] original, int newlen)

  - ### copyOf

    public static int[] copyOf(int[] original, int newlen)

  - ### copyOf

    public static byte[] copyOf(byte[] original, int newlen)

  - ### copyOf

    public static short[] copyOf(short[] original, int len)