XArrays (Pitaya 0.2 API)

java.lang.Object
- org.kocakosm.pitaya.util.XArrays

```
public final class XArrays
extends Object
```
Various extra utilities for arrays.

Author:

Osman KOCAK

See Also:
Arrays

Method Summary

Methods
Modifier and Type	Method and Description
`static boolean[]`	`concat(boolean[]... arrays)` Concatenates the given arrays into a single one.
`static byte[]`	`concat(byte[]... arrays)` Concatenates the given arrays into a single one.
`static char[]`	`concat(char[]... arrays)` Concatenates the given arrays into a single one.
`static double[]`	`concat(double[]... arrays)` Concatenates the given arrays into a single one.
`static float[]`	`concat(float[]... arrays)` Concatenates the given arrays into a single one.
`static int[]`	`concat(int[]... arrays)` Concatenates the given arrays into a single one.
`static long[]`	`concat(long[]... arrays)` Concatenates the given arrays into a single one.
`static short[]`	`concat(short[]... arrays)` Concatenates the given arrays into a single one.
`static <T> T[]`	`concat(T[]... arrays)` Concatenates the given arrays into a single one.
`static boolean[]`	`copyOf(boolean... original)` Returns a copy of the given array.
`static boolean[]`	`copyOf(boolean[] a, int off, int len)` Copies the specified range of elements from the given array into a new array.
`static byte[]`	`copyOf(byte... original)` Returns a copy of the given array.
`static byte[]`	`copyOf(byte[] a, int off, int len)` Copies the specified range of elements from the given array into a new array.
`static char[]`	`copyOf(char... original)` Returns a copy of the given array.
`static char[]`	`copyOf(char[] a, int off, int len)` Copies the specified range of elements from the given array into a new array.
`static double[]`	`copyOf(double... original)` Returns a copy of the given array.
`static double[]`	`copyOf(double[] a, int off, int len)` Copies the specified range of elements from the given array into a new array.
`static float[]`	`copyOf(float... original)` Returns a copy of the given array.
`static float[]`	`copyOf(float[] a, int off, int len)` Copies the specified range of elements from the given array into a new array.
`static int[]`	`copyOf(int... original)` Returns a copy of the given array.
`static int[]`	`copyOf(int[] a, int off, int len)` Copies the specified range of elements from the given array into a new array.
`static long[]`	`copyOf(long... original)` Returns a copy of the given array.
`static long[]`	`copyOf(long[] a, int off, int len)` Copies the specified range of elements from the given array into a new array.
`static short[]`	`copyOf(short... original)` Returns a copy of the given array.
`static short[]`	`copyOf(short[] a, int off, int len)` Copies the specified range of elements from the given array into a new array.
`static <T> T[]`	`copyOf(T[] original)` Returns a copy of the given array.
`static <T> T[]`	`copyOf(T[] a, int off, int len)` Copies the specified range of elements from the given array into a new array.
`static boolean`	`isNullOrEmpty(boolean[] a)` Returns whether the given array is `null` or `empty`, that is, returns `true` if `a` is `null` or empty and `false` otherwise.
`static boolean`	`isNullOrEmpty(byte[] a)` Returns whether the given array is `null` or `empty`, that is, returns `true` if `a` is `null` or empty and `false` otherwise.
`static boolean`	`isNullOrEmpty(char[] a)` Returns whether the given array is `null` or `empty`, that is, returns `true` if `a` is `null` or empty and `false` otherwise.
`static boolean`	`isNullOrEmpty(double[] a)` Returns whether the given array is `null` or `empty`, that is, returns `true` if `a` is `null` or empty and `false` otherwise.
`static boolean`	`isNullOrEmpty(float[] a)` Returns whether the given array is `null` or `empty`, that is, returns `true` if `a` is `null` or empty and `false` otherwise.
`static boolean`	`isNullOrEmpty(int[] a)` Returns whether the given array is `null` or `empty`, that is, returns `true` if `a` is `null` or empty and `false` otherwise.
`static boolean`	`isNullOrEmpty(long[] a)` Returns whether the given array is `null` or `empty`, that is, returns `true` if `a` is `null` or empty and `false` otherwise.
`static boolean`	`isNullOrEmpty(Object[] a)` Returns whether the given array is `null` or `empty`, that is, returns `true` if `a` is `null` or empty and `false` otherwise.
`static boolean`	`isNullOrEmpty(short[] a)` Returns whether the given array is `null` or `empty`, that is, returns `true` if `a` is `null` or empty and `false` otherwise.
`static boolean[]`	`reverse(boolean... a)` Returns a new array containing the same elements as the given one, but in reverse order.
`static byte[]`	`reverse(byte... a)` Returns a new array containing the same elements as the given one, but in reverse order.
`static char[]`	`reverse(char... a)` Returns a new array containing the same elements as the given one, but in reverse order.
`static double[]`	`reverse(double... a)` Returns a new array containing the same elements as the given one, but in reverse order.
`static float[]`	`reverse(float... a)` Returns a new array containing the same elements as the given one, but in reverse order.
`static int[]`	`reverse(int... a)` Returns a new array containing the same elements as the given one, but in reverse order.
`static long[]`	`reverse(long... a)` Returns a new array containing the same elements as the given one, but in reverse order.
`static short[]`	`reverse(short... a)` Returns a new array containing the same elements as the given one, but in reverse order.
`static <T> T[]`	`reverse(T[] a)` Returns a new array containing the same elements as the given one, but in reverse order.
`static boolean[]`	`rotate(boolean[] a, int distance)` Returns a new array containing the same elements as the given one, but rotated by the given distance.
`static byte[]`	`rotate(byte[] a, int distance)` Returns a new array containing the same elements as the given one, but rotated by the given distance.
`static char[]`	`rotate(char[] a, int distance)` Returns a new array containing the same elements as the given one, but rotated by the given distance.
`static double[]`	`rotate(double[] a, int distance)` Returns a new array containing the same elements as the given one, but rotated by the given distance.
`static float[]`	`rotate(float[] a, int distance)` Returns a new array containing the same elements as the given one, but rotated by the given distance.
`static int[]`	`rotate(int[] a, int distance)` Returns a new array containing the same elements as the given one, but rotated by the given distance.
`static long[]`	`rotate(long[] a, int distance)` Returns a new array containing the same elements as the given one, but rotated by the given distance.
`static short[]`	`rotate(short[] a, int distance)` Returns a new array containing the same elements as the given one, but rotated by the given distance.
`static <T> T[]`	`rotate(T[] a, int distance)` Returns a new array containing the same elements as the given one, but rotated by the given distance.
`static boolean[]`	`shuffle(boolean... a)` Returns a copy of the given array where its element have been randomly permuted.
`static boolean[]`	`shuffle(boolean[] a, Random rnd)` Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness.
`static byte[]`	`shuffle(byte... a)` Returns a copy of the given array where its element have been randomly permuted.
`static byte[]`	`shuffle(byte[] a, Random rnd)` Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness.
`static char[]`	`shuffle(char... a)` Returns a copy of the given array where its element have been randomly permuted.
`static char[]`	`shuffle(char[] a, Random rnd)` Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness.
`static double[]`	`shuffle(double... a)` Returns a copy of the given array where its element have been randomly permuted.
`static double[]`	`shuffle(double[] a, Random rnd)` Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness.
`static float[]`	`shuffle(float... a)` Returns a copy of the given array where its element have been randomly permuted.
`static float[]`	`shuffle(float[] a, Random rnd)` Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness.
`static int[]`	`shuffle(int... a)` Returns a copy of the given array where its element have been randomly permuted.
`static int[]`	`shuffle(int[] a, Random rnd)` Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness.
`static long[]`	`shuffle(long... a)` Returns a copy of the given array where its element have been randomly permuted.
`static long[]`	`shuffle(long[] a, Random rnd)` Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness.
`static short[]`	`shuffle(short... a)` Returns a copy of the given array where its element have been randomly permuted.
`static short[]`	`shuffle(short[] a, Random rnd)` Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness.
`static <T> T[]`	`shuffle(T[] a)` Returns a copy of the given array where its element have been randomly permuted.
`static <T> T[]`	`shuffle(T[] a, Random rnd)` Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness.
`static byte[]`	`sort(byte... a)` Returns a sorted copy of the given array into ascending numerical order.
`static char[]`	`sort(char... a)` Returns a sorted copy of the given array into ascending numerical order.
`static double[]`	`sort(double... a)` Returns a sorted copy of the given array into ascending numerical order.
`static float[]`	`sort(float... a)` Returns a sorted copy of the given array into ascending numerical order.
`static int[]`	`sort(int... a)` Returns a sorted copy of the given array into ascending numerical order.
`static long[]`	`sort(long... a)` Returns a sorted copy of the given array into ascending numerical order.
`static short[]`	`sort(short... a)` Returns a sorted copy of the given array into ascending numerical order.
`static <T> T[]`	`sort(T[] a)` Returns a sorted copy of the given array of objects into ascending order, according to the natural ordering of its elements (all elements in the array must implement the `Comparable` interface).
`static <T> T[]`	`sort(T[] a, Comparator<? super T> c)` Returns a sorted copy of the given array of objects into ascending order, according to the order induced by the given `Comparator`.
`static Boolean[]`	`toObject(boolean... a)` Converts an array of `boolean`s to an array of `Boolean`s.
`static Byte[]`	`toObject(byte... a)` Converts an array of `byte`s to an array of `Byte`s.
`static Character[]`	`toObject(char... a)` Converts an array of `char`s to an array of `Character`s.
`static Double[]`	`toObject(double... a)` Converts an array of `double`s to an array of `Double`s.
`static Float[]`	`toObject(float... a)` Converts an array of `float`s to an array of `Float`s.
`static Integer[]`	`toObject(int... a)` Converts an array of `int`s to an array of `Integer`s.
`static Long[]`	`toObject(long... a)` Converts an array of `long`s to an array of `Long`s.
`static Short[]`	`toObject(short... a)` Converts an array of `short`s to an array of `Short`s.
`static boolean[]`	`toPrimitive(Boolean... a)` Converts an array of `Boolean`s to an array of `boolean`s.
`static byte[]`	`toPrimitive(Byte... a)` Converts an array of `Byte`s to an array of `byte`s.
`static char[]`	`toPrimitive(Character... a)` Converts an array of `Character`s to an array of `char`s.
`static double[]`	`toPrimitive(Double... a)` Converts an array of `Double`s to an array of `double`s.
`static float[]`	`toPrimitive(Float... a)` Converts an array of `Float`s to an array of `float`s.
`static int[]`	`toPrimitive(Integer... a)` Converts an array of `Integer`s to an array of `int`s.
`static long[]`	`toPrimitive(Long... a)` Converts an array of `Long`s to an array of `long`s.
`static short[]`	`toPrimitive(Short... a)` Converts an array of `Short`s to an array of `short`s.
`static String`	`toString(boolean... a)` Returns a `String` representation of the contents of the given array.
`static String`	`toString(byte... a)` Returns a `String` representation of the contents of the given array.
`static String`	`toString(char... a)` Returns a `String` representation of the contents of the given array.
`static String`	`toString(double... a)` Returns a `String` representation of the contents of the given array.
`static String`	`toString(float... a)` Returns a `String` representation of the contents of the given array.
`static String`	`toString(int... a)` Returns a `String` representation of the contents of the given array.
`static String`	`toString(long... a)` Returns a `String` representation of the contents of the given array.
`static String`	`toString(Object[] a)` Returns a `String` representation of the contents of the given array.
`static String`	`toString(short... a)` Returns a `String` representation of the contents of the given array.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - isNullOrEmpty
```
public static boolean isNullOrEmpty(long[] a)
```
    Returns whether the given array is null or empty, that is, returns true if a is null or empty and false otherwise.
    
    Parameters:
    a - the array to test.
    
    Returns:
    whether the given array is null or empty.
  - isNullOrEmpty
```
public static boolean isNullOrEmpty(int[] a)
```
    Returns whether the given array is null or empty, that is, returns true if a is null or empty and false otherwise.
    
    Parameters:
    a - the array to test.
    
    Returns:
    whether the given array is null or empty.
  - isNullOrEmpty
```
public static boolean isNullOrEmpty(short[] a)
```
    Returns whether the given array is null or empty, that is, returns true if a is null or empty and false otherwise.
    
    Parameters:
    a - the array to test.
    
    Returns:
    whether the given array is null or empty.
  - isNullOrEmpty
```
public static boolean isNullOrEmpty(char[] a)
```
    Returns whether the given array is null or empty, that is, returns true if a is null or empty and false otherwise.
    
    Parameters:
    a - the array to test.
    
    Returns:
    whether the given array is null or empty.
  - isNullOrEmpty
```
public static boolean isNullOrEmpty(byte[] a)
```
    Returns whether the given array is null or empty, that is, returns true if a is null or empty and false otherwise.
    
    Parameters:
    a - the array to test.
    
    Returns:
    whether the given array is null or empty.
  - isNullOrEmpty
```
public static boolean isNullOrEmpty(boolean[] a)
```
    Returns whether the given array is null or empty, that is, returns true if a is null or empty and false otherwise.
    
    Parameters:
    a - the array to test.
    
    Returns:
    whether the given array is null or empty.
  - isNullOrEmpty
```
public static boolean isNullOrEmpty(float[] a)
```
    Returns whether the given array is null or empty, that is, returns true if a is null or empty and false otherwise.
    
    Parameters:
    a - the array to test.
    
    Returns:
    whether the given array is null or empty.
  - isNullOrEmpty
```
public static boolean isNullOrEmpty(double[] a)
```
    Returns whether the given array is null or empty, that is, returns true if a is null or empty and false otherwise.
    
    Parameters:
    a - the array to test.
    
    Returns:
    whether the given array is null or empty.
  - isNullOrEmpty
```
public static boolean isNullOrEmpty(Object[] a)
```
    Returns whether the given array is null or empty, that is, returns true if a is null or empty and false otherwise.
    
    Parameters:
    a - the array to test.
    
    Returns:
    whether the given array is null or empty.
  - concat
```
public static long[] concat(long[]... arrays)
```
    Concatenates the given arrays into a single one.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the concatenated array.
    
    Throws:
    
    NullPointerException - if arrays is null or if it contains a null reference.
  - concat
```
public static int[] concat(int[]... arrays)
```
    Concatenates the given arrays into a single one.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the concatenated array.
    
    Throws:
    
    NullPointerException - if arrays is null or if it contains a null reference.
  - concat
```
public static short[] concat(short[]... arrays)
```
    Concatenates the given arrays into a single one.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the concatenated array.
    
    Throws:
    
    NullPointerException - if arrays is null or if it contains a null reference.
  - concat
```
public static char[] concat(char[]... arrays)
```
    Concatenates the given arrays into a single one.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the concatenated array.
    
    Throws:
    
    NullPointerException - if arrays is null or if it contains a null reference.
  - concat
```
public static byte[] concat(byte[]... arrays)
```
    Concatenates the given arrays into a single one.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the concatenated array.
    
    Throws:
    
    NullPointerException - if arrays is null or if it contains a null reference.
  - concat
```
public static boolean[] concat(boolean[]... arrays)
```
    Concatenates the given arrays into a single one.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the concatenated array.
    
    Throws:
    
    NullPointerException - if arrays is null or if it contains a null reference.
  - concat
```
public static float[] concat(float[]... arrays)
```
    Concatenates the given arrays into a single one.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the concatenated array.
    
    Throws:
    
    NullPointerException - if arrays is null or if it contains a null reference.
  - concat
```
public static double[] concat(double[]... arrays)
```
    Concatenates the given arrays into a single one.
    
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the concatenated array.
    
    Throws:
    
    NullPointerException - if arrays is null or if it contains a null reference.
  - concat
```
public static <T> T[] concat(T[]... arrays)
```
    Concatenates the given arrays into a single one.
    
    Type Parameters:
    T - the type of the elements in the arrays to concatenate.
    Parameters:
    arrays - the arrays to concatenate.
    
    Returns:
    the concatenated array.
    
    Throws:
    
    IllegalArgumentException - if arrays is empty.
    
    NullPointerException - if arrays is null or if it contains a null reference.
  - copyOf
```
public static long[] copyOf(long[] a,
            int off,
            int len)
```
    Copies the specified range of elements from the given array into a new array. The returned array will be padded with 0, if necessary, so that it has an exact length of len.
    
    Parameters:
    a - the source array.
    off - the starting position in the source array.
    len - the number of elements to copy (returned array's length).
    
    Returns:
    a new array containing the specified range of the source array.
    
    Throws:
    
    NullPointerException - if a is null.
    
    ArrayIndexOutOfBoundsException - if off is negative.
    
    NegativeArraySizeException - if len is negative.
  - copyOf
```
public static int[] copyOf(int[] a,
           int off,
           int len)
```
    Copies the specified range of elements from the given array into a new array. The returned array will be padded with 0, if necessary, so that it has an exact length of len.
    
    Parameters:
    a - the source array.
    off - the starting position in the source array.
    len - the number of elements to copy (returned array's length).
    
    Returns:
    a new array containing the specified range of the source array.
    
    Throws:
    
    NullPointerException - if a is null.
    
    ArrayIndexOutOfBoundsException - if off is negative.
    
    NegativeArraySizeException - if len is negative.
  - copyOf
```
public static short[] copyOf(short[] a,
             int off,
             int len)
```
    Copies the specified range of elements from the given array into a new array. The returned array will be padded with 0, if necessary, so that it has an exact length of len.
    
    Parameters:
    a - the source array.
    off - the starting position in the source array.
    len - the number of elements to copy (returned array's length).
    
    Returns:
    a new array containing the specified range of the source array.
    
    Throws:
    
    NullPointerException - if a is null.
    
    ArrayIndexOutOfBoundsException - if off is negative.
    
    NegativeArraySizeException - if len is negative.
  - copyOf
```
public static char[] copyOf(char[] a,
            int off,
            int len)
```
    Copies the specified range of elements from the given array into a new array. The returned array will be padded with 0, if necessary, so that it has an exact length of len.
    
    Parameters:
    a - the source array.
    off - the starting position in the source array.
    len - the number of elements to copy (returned array's length).
    
    Returns:
    a new array containing the specified range of the source array.
    
    Throws:
    
    NullPointerException - if a is null.
    
    ArrayIndexOutOfBoundsException - if off is negative.
    
    NegativeArraySizeException - if len is negative.
  - copyOf
```
public static byte[] copyOf(byte[] a,
            int off,
            int len)
```
    Copies the specified range of elements from the given array into a new array. The returned array will be padded with 0, if necessary, so that it has an exact length of len.
    
    Parameters:
    a - the source array.
    off - the starting position in the source array.
    len - the number of elements to copy (returned array's length).
    
    Returns:
    a new array containing the specified range of the source array.
    
    Throws:
    
    NullPointerException - if a is null.
    
    ArrayIndexOutOfBoundsException - if off is negative.
    
    NegativeArraySizeException - if len is negative.
  - copyOf
```
public static boolean[] copyOf(boolean[] a,
               int off,
               int len)
```
    Copies the specified range of elements from the given array into a new array. The returned array will be padded with false, if necessary, so that it has an exact length of len.
    
    Parameters:
    a - the source array.
    off - the starting position in the source array.
    len - the number of elements to copy (returned array's length).
    
    Returns:
    a new array containing the specified range of the source array.
    
    Throws:
    
    NullPointerException - if a is null.
    
    ArrayIndexOutOfBoundsException - if off is negative.
    
    NegativeArraySizeException - if len is negative.
  - copyOf
```
public static float[] copyOf(float[] a,
             int off,
             int len)
```
    Copies the specified range of elements from the given array into a new array. The returned array will be padded with 0.0, if necessary, so that it has an exact length of len.
    
    Parameters:
    a - the source array.
    off - the starting position in the source array.
    len - the number of elements to copy (returned array's length).
    
    Returns:
    a new array containing the specified range of the source array.
    
    Throws:
    
    NullPointerException - if a is null.
    
    ArrayIndexOutOfBoundsException - if off is negative.
    
    NegativeArraySizeException - if len is negative.
  - copyOf
```
public static double[] copyOf(double[] a,
              int off,
              int len)
```
    Copies the specified range of elements from the given array into a new array. The returned array will be padded with 0.0, if necessary, so that it has an exact length of len.
    
    Parameters:
    a - the source array.
    off - the starting position in the source array.
    len - the number of elements to copy (returned array's length).
    
    Returns:
    a new array containing the specified range of the source array.
    
    Throws:
    
    NullPointerException - if a is null.
    
    ArrayIndexOutOfBoundsException - if off is negative.
    
    NegativeArraySizeException - if len is negative.
  - copyOf
```
public static <T> T[] copyOf(T[] a,
             int off,
             int len)
```
    Copies the specified range of elements from the given array into a new array. The returned array will be padded with null, if necessary, so that it has an exact length of len.
    
    Type Parameters:
    T - the type of the elements in the array to copy.
    Parameters:
    a - the source array.
    off - the starting position in the source array.
    len - the number of elements to copy (returned array's length).
    
    Returns:
    a new array containing the specified range of the source array.
    
    Throws:
    
    NullPointerException - if a is null.
    
    ArrayIndexOutOfBoundsException - if off is negative.
    
    NegativeArraySizeException - if len is negative.
  - copyOf
```
public static long[] copyOf(long... original)
```
    Returns a copy of the given array. The original array and the returned copy will have identical length and content.
    
    Parameters:
    original - the array to be copied.
    
    Returns:
    a copy of the original array.
    
    Throws:
    
    NullPointerException - if original is null.
  - copyOf
```
public static int[] copyOf(int... original)
```
    Returns a copy of the given array. The original array and the returned copy will have identical length and content.
    
    Parameters:
    original - the array to be copied.
    
    Returns:
    a copy of the original array.
    
    Throws:
    
    NullPointerException - if original is null.
  - copyOf
```
public static short[] copyOf(short... original)
```
    Returns a copy of the given array. The original array and the returned copy will have identical length and content.
    
    Parameters:
    original - the array to be copied.
    
    Returns:
    a copy of the original array.
    
    Throws:
    
    NullPointerException - if original is null.
  - copyOf
```
public static char[] copyOf(char... original)
```
    Returns a copy of the given array. The original array and the returned copy will have identical length and content.
    
    Parameters:
    original - the array to be copied.
    
    Returns:
    a copy of the original array.
    
    Throws:
    
    NullPointerException - if original is null.
  - copyOf
```
public static byte[] copyOf(byte... original)
```
    Returns a copy of the given array. The original array and the returned copy will have identical length and content.
    
    Parameters:
    original - the array to be copied.
    
    Returns:
    a copy of the original array.
    
    Throws:
    
    NullPointerException - if original is null.
  - copyOf
```
public static boolean[] copyOf(boolean... original)
```
    Returns a copy of the given array. The original array and the returned copy will have identical length and content.
    
    Parameters:
    original - the array to be copied.
    
    Returns:
    a copy of the original array.
    
    Throws:
    
    NullPointerException - if original is null.
  - copyOf
```
public static float[] copyOf(float... original)
```
    Returns a copy of the given array. The original array and the returned copy will have identical length and content.
    
    Parameters:
    original - the array to be copied.
    
    Returns:
    a copy of the original array.
    
    Throws:
    
    NullPointerException - if original is null.
  - copyOf
```
public static double[] copyOf(double... original)
```
    Returns a copy of the given array. The original array and the returned copy will have identical length and content.
    
    Parameters:
    original - the array to be copied.
    
    Returns:
    a copy of the original array.
    
    Throws:
    
    NullPointerException - if original is null.
  - copyOf
```
public static <T> T[] copyOf(T[] original)
```
    Returns a copy of the given array. The original array and the returned copy will have identical length and content.
    
    Type Parameters:
    T - the type of the elements in the array to copy.
    Parameters:
    original - the array to be copied.
    
    Returns:
    a copy of the original array.
    
    Throws:
    
    NullPointerException - if original is null.
  - reverse
```
public static long[] reverse(long... a)
```
    Returns a new array containing the same elements as the given one, but in reverse order.
    
    Parameters:
    a - the array to reverse.
    
    Returns:
    the reversed array.
    
    Throws:
    
    NullPointerException - if a is null.
  - reverse
```
public static int[] reverse(int... a)
```
    Returns a new array containing the same elements as the given one, but in reverse order.
    
    Parameters:
    a - the array to reverse.
    
    Returns:
    the reversed array.
    
    Throws:
    
    NullPointerException - if a is null.
  - reverse
```
public static short[] reverse(short... a)
```
    Returns a new array containing the same elements as the given one, but in reverse order.
    
    Parameters:
    a - the array to reverse.
    
    Returns:
    the reversed array.
    
    Throws:
    
    NullPointerException - if a is null.
  - reverse
```
public static char[] reverse(char... a)
```
    Returns a new array containing the same elements as the given one, but in reverse order.
    
    Parameters:
    a - the array to reverse.
    
    Returns:
    the reversed array.
    
    Throws:
    
    NullPointerException - if a is null.
  - reverse
```
public static byte[] reverse(byte... a)
```
    Returns a new array containing the same elements as the given one, but in reverse order.
    
    Parameters:
    a - the array to reverse.
    
    Returns:
    the reversed array.
    
    Throws:
    
    NullPointerException - if a is null.
  - reverse
```
public static boolean[] reverse(boolean... a)
```
    Returns a new array containing the same elements as the given one, but in reverse order.
    
    Parameters:
    a - the array to reverse.
    
    Returns:
    the reversed array.
    
    Throws:
    
    NullPointerException - if a is null.
  - reverse
```
public static float[] reverse(float... a)
```
    Returns a new array containing the same elements as the given one, but in reverse order.
    
    Parameters:
    a - the array to reverse.
    
    Returns:
    the reversed array.
    
    Throws:
    
    NullPointerException - if a is null.
  - reverse
```
public static double[] reverse(double... a)
```
    Returns a new array containing the same elements as the given one, but in reverse order.
    
    Parameters:
    a - the array to reverse.
    
    Returns:
    the reversed array.
    
    Throws:
    
    NullPointerException - if a is null.
  - reverse
```
public static <T> T[] reverse(T[] a)
```
    Returns a new array containing the same elements as the given one, but in reverse order.
    
    Type Parameters:
    T - the type of the elements in the array to reverse.
    Parameters:
    a - the array to reverse.
    
    Returns:
    the reversed array.
    
    Throws:
    
    NullPointerException - if a is null.
  - rotate
```
public static long[] rotate(long[] a,
            int distance)
```
    Returns a new array containing the same elements as the given one, but rotated by the given distance. The element at index i in the returned array corresponds to the element in the original array at index (i - distance) mod a.length, for all values of i between 0 and a.length - 1, inclusive. Note that rotation by 0 or by a multiple of a.length is a no-op.
    
    Parameters:
    a - the array to rotate.
    distance - the distance to rotate.
    
    Returns:
    the rotated array.
    
    Throws:
    
    NullPointerException - if a is null.
  - rotate
```
public static int[] rotate(int[] a,
           int distance)
```
    Returns a new array containing the same elements as the given one, but rotated by the given distance. The element at index i in the returned array corresponds to the element in the original array at index (i - distance) mod a.length, for all values of i between 0 and a.length - 1, inclusive. Note that rotation by 0 or by a multiple of a.length is a no-op.
    
    Parameters:
    a - the array to rotate.
    distance - the distance to rotate.
    
    Returns:
    the rotated array.
    
    Throws:
    
    NullPointerException - if a is null.
  - rotate
```
public static short[] rotate(short[] a,
             int distance)
```
    Returns a new array containing the same elements as the given one, but rotated by the given distance. The element at index i in the returned array corresponds to the element in the original array at index (i - distance) mod a.length, for all values of i between 0 and a.length - 1, inclusive. Note that rotation by 0 or by a multiple of a.length is a no-op.
    
    Parameters:
    a - the array to rotate.
    distance - the distance to rotate.
    
    Returns:
    the rotated array.
    
    Throws:
    
    NullPointerException - if a is null.
  - rotate
```
public static char[] rotate(char[] a,
            int distance)
```
    Returns a new array containing the same elements as the given one, but rotated by the given distance. The element at index i in the returned array corresponds to the element in the original array at index (i - distance) mod a.length, for all values of i between 0 and a.length - 1, inclusive. Note that rotation by 0 or by a multiple of a.length is a no-op.
    
    Parameters:
    a - the array to rotate.
    distance - the distance to rotate.
    
    Returns:
    the rotated array.
    
    Throws:
    
    NullPointerException - if a is null.
  - rotate
```
public static byte[] rotate(byte[] a,
            int distance)
```
    Returns a new array containing the same elements as the given one, but rotated by the given distance. The element at index i in the returned array corresponds to the element in the original array at index (i - distance) mod a.length, for all values of i between 0 and a.length - 1, inclusive. Note that rotation by 0 or by a multiple of a.length is a no-op.
    
    Parameters:
    a - the array to rotate.
    distance - the distance to rotate.
    
    Returns:
    the rotated array.
    
    Throws:
    
    NullPointerException - if a is null.
  - rotate
```
public static boolean[] rotate(boolean[] a,
               int distance)
```
    Returns a new array containing the same elements as the given one, but rotated by the given distance. The element at index i in the returned array corresponds to the element in the original array at index (i - distance) mod a.length, for all values of i between 0 and a.length - 1, inclusive. Note that rotation by 0 or by a multiple of a.length is a no-op.
    
    Parameters:
    a - the array to rotate.
    distance - the distance to rotate.
    
    Returns:
    the rotated array.
    
    Throws:
    
    NullPointerException - if a is null.
  - rotate
```
public static float[] rotate(float[] a,
             int distance)
```
    Returns a new array containing the same elements as the given one, but rotated by the given distance. The element at index i in the returned array corresponds to the element in the original array at index (i - distance) mod a.length, for all values of i between 0 and a.length - 1, inclusive. Note that rotation by 0 or by a multiple of a.length is a no-op.
    
    Parameters:
    a - the array to rotate.
    distance - the distance to rotate.
    
    Returns:
    the rotated array.
    
    Throws:
    
    NullPointerException - if a is null.
  - rotate
```
public static double[] rotate(double[] a,
              int distance)
```
    Returns a new array containing the same elements as the given one, but rotated by the given distance. The element at index i in the returned array corresponds to the element in the original array at index (i - distance) mod a.length, for all values of i between 0 and a.length - 1, inclusive. Note that rotation by 0 or by a multiple of a.length is a no-op.
    
    Parameters:
    a - the array to rotate.
    distance - the distance to rotate.
    
    Returns:
    the rotated array.
    
    Throws:
    
    NullPointerException - if a is null.
  - rotate
```
public static <T> T[] rotate(T[] a,
             int distance)
```
    Returns a new array containing the same elements as the given one, but rotated by the given distance. The element at index i in the returned array corresponds to the element in the original array at index (i - distance) mod a.length, for all values of i between 0 and a.length - 1, inclusive. Note that rotation by 0 or by a multiple of a.length is a no-op.
    
    Type Parameters:
    T - the type of the elements in the array to rotate.
    Parameters:
    a - the array to rotate.
    distance - the distance to rotate.
    
    Returns:
    the rotated array.
    
    Throws:
    
    NullPointerException - if a is null.
  - shuffle
```
public static long[] shuffle(long... a)
```
    Returns a copy of the given array where its element have been randomly permuted. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if a is null.
  - shuffle
```
public static long[] shuffle(long[] a,
             Random rnd)
```
    Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness. All permutations occur with equal likelihood assuming that the source of randomness is fair. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    rnd - the source of randomness to use.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if one of the arguments is null.
  - shuffle
```
public static int[] shuffle(int... a)
```
    Returns a copy of the given array where its element have been randomly permuted. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if a is null.
  - shuffle
```
public static int[] shuffle(int[] a,
            Random rnd)
```
    Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness. All permutations occur with equal likelihood assuming that the source of randomness is fair. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    rnd - the source of randomness to use.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if one of the arguments is null.
  - shuffle
```
public static short[] shuffle(short... a)
```
    Returns a copy of the given array where its element have been randomly permuted. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if a is null.
  - shuffle
```
public static short[] shuffle(short[] a,
              Random rnd)
```
    Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness. All permutations occur with equal likelihood assuming that the source of randomness is fair. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    rnd - the source of randomness to use.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if one of the arguments is null.
  - shuffle
```
public static char[] shuffle(char... a)
```
    Returns a copy of the given array where its element have been randomly permuted. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if a is null.
  - shuffle
```
public static char[] shuffle(char[] a,
             Random rnd)
```
    Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness. All permutations occur with equal likelihood assuming that the source of randomness is fair. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    rnd - the source of randomness to use.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if one of the arguments is null.
  - shuffle
```
public static byte[] shuffle(byte... a)
```
    Returns a copy of the given array where its element have been randomly permuted. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if a is null.
  - shuffle
```
public static byte[] shuffle(byte[] a,
             Random rnd)
```
    Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness. All permutations occur with equal likelihood assuming that the source of randomness is fair. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    rnd - the source of randomness to use.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if one of the arguments is null.
  - shuffle
```
public static boolean[] shuffle(boolean... a)
```
    Returns a copy of the given array where its element have been randomly permuted. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if a is null.
  - shuffle
```
public static boolean[] shuffle(boolean[] a,
                Random rnd)
```
    Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness. All permutations occur with equal likelihood assuming that the source of randomness is fair. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    rnd - the source of randomness to use.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if one of the arguments is null.
  - shuffle
```
public static float[] shuffle(float... a)
```
    Returns a copy of the given array where its element have been randomly permuted. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if a is null.
  - shuffle
```
public static float[] shuffle(float[] a,
              Random rnd)
```
    Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness. All permutations occur with equal likelihood assuming that the source of randomness is fair. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    rnd - the source of randomness to use.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if one of the arguments is null.
  - shuffle
```
public static double[] shuffle(double... a)
```
    Returns a copy of the given array where its element have been randomly permuted. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if a is null.
  - shuffle
```
public static double[] shuffle(double[] a,
               Random rnd)
```
    Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness. All permutations occur with equal likelihood assuming that the source of randomness is fair. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Parameters:
    a - the array whose content will be shuffled.
    rnd - the source of randomness to use.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if one of the arguments is null.
  - shuffle
```
public static <T> T[] shuffle(T[] a)
```
    Returns a copy of the given array where its element have been randomly permuted. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Type Parameters:
    T - the type of the elements in the array to shuffle.
    Parameters:
    a - the array whose content will be shuffled.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if a is null.
  - shuffle
```
public static <T> T[] shuffle(T[] a,
              Random rnd)
```
    Returns a copy of the given array where its element have been randomly permuted using the specified source of randomness. All permutations occur with equal likelihood assuming that the source of randomness is fair. This method uses the optimized version of the Fisher-Yates shuffle algorithm (Fisher, Yates, Durstenfeld, Knuth) and thus runs in linear time.
    
    Type Parameters:
    T - the type of the elements in the array to shuffle.
    Parameters:
    a - the array whose content will be shuffled.
    rnd - the source of randomness to use.
    
    Returns:
    the shuffled array.
    
    Throws:
    
    NullPointerException - if one of the arguments is null.
  - sort
```
public static long[] sort(long... a)
```
    Returns a sorted copy of the given array into ascending numerical order.
    
    Parameters:
    a - the array to be sorted.
    
    Returns:
    a sorted copy of the given array.
    
    Throws:
    
    NullPointerException - if a is null.
    See Also:
    Arrays.sort(long[])
  - sort
```
public static int[] sort(int... a)
```
    Returns a sorted copy of the given array into ascending numerical order.
    
    Parameters:
    a - the array to be sorted.
    
    Returns:
    a sorted copy of the given array.
    
    Throws:
    
    NullPointerException - if a is null.
    See Also:
    Arrays.sort(int[])
  - sort
```
public static short[] sort(short... a)
```
    Returns a sorted copy of the given array into ascending numerical order.
    
    Parameters:
    a - the array to be sorted.
    
    Returns:
    a sorted copy of the given array.
    
    Throws:
    
    NullPointerException - if a is null.
    See Also:
    Arrays.sort(short[])
  - sort
```
public static char[] sort(char... a)
```
    Returns a sorted copy of the given array into ascending numerical order.
    
    Parameters:
    a - the array to be sorted.
    
    Returns:
    a sorted copy of the given array.
    
    Throws:
    
    NullPointerException - if a is null.
    See Also:
    Arrays.sort(char[])
  - sort
```
public static byte[] sort(byte... a)
```
    Returns a sorted copy of the given array into ascending numerical order.
    
    Parameters:
    a - the array to be sorted.
    
    Returns:
    a sorted copy of the given array.
    
    Throws:
    
    NullPointerException - if a is null.
    See Also:
    Arrays.sort(byte[])
  - sort
```
public static float[] sort(float... a)
```
    Returns a sorted copy of the given array into ascending numerical order.
    
    Parameters:
    a - the array to be sorted.
    
    Returns:
    a sorted copy of the given array.
    
    Throws:
    
    NullPointerException - if a is null.
    See Also:
    Arrays.sort(float[])
  - sort
```
public static double[] sort(double... a)
```
    Returns a sorted copy of the given array into ascending numerical order.
    
    Parameters:
    a - the array to be sorted.
    
    Returns:
    a sorted copy of the given array.
    
    Throws:
    
    NullPointerException - if a is null.
    See Also:
    Arrays.sort(double[])
  - sort
```
public static <T> T[] sort(T[] a)
```
    Returns a sorted copy of the given array of objects into ascending order, according to the natural ordering of its elements (all elements in the array must implement the Comparable interface).
    
    Type Parameters:
    T - the type of the elements in the array to sort.
    Parameters:
    a - the array to be sorted.
    
    Returns:
    a sorted copy of the given array.
    
    Throws:
    
    NullPointerException - if a is null.
    
    ClassCastException - if the array contains elements that are not mutually comparable (for example, Strings and Integers).
    
    IllegalArgumentException - if the natural ordering of the array elements is found to violate the Comparable contract.
    See Also:
    Arrays.sort(java.lang.Object[])
  - sort
```
public static <T> T[] sort(T[] a,
           Comparator<? super T> c)
```
    Returns a sorted copy of the given array of objects into ascending order, according to the order induced by the given Comparator.
    
    Type Parameters:
    T - the type of the elements in the array to sort.
    Parameters:
    a - the array to be sorted.
    c - the comparator to determine the order of the array.
    
    Returns:
    a sorted copy of the given array.
    
    Throws:
    
    NullPointerException - if a or c is null.
    
    ClassCastException - if the array contains elements that are not mutually comparable (for example, Strings and Integers).
    See Also:
    Arrays.sort(java.lang.Object[], java.util.Comparator)
  - toPrimitive
```
public static long[] toPrimitive(Long... a)
```
    Converts an array of Longs to an array of longs. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the Long array to convert.
    
    Returns:
    the corresponding long array.
    
    Throws:
    
    NullPointerException - if a contains a null value.
  - toPrimitive
```
public static int[] toPrimitive(Integer... a)
```
    Converts an array of Integers to an array of ints. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the Integer array to convert.
    
    Returns:
    the corresponding int array.
    
    Throws:
    
    NullPointerException - if a contains a null value.
  - toPrimitive
```
public static short[] toPrimitive(Short... a)
```
    Converts an array of Shorts to an array of shorts. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the Short array to convert.
    
    Returns:
    the corresponding short array.
    
    Throws:
    
    NullPointerException - if a contains a null value.
  - toPrimitive
```
public static char[] toPrimitive(Character... a)
```
    Converts an array of Characters to an array of chars. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the Character array to convert.
    
    Returns:
    the corresponding char array.
    
    Throws:
    
    NullPointerException - if a contains a null value.
  - toPrimitive
```
public static byte[] toPrimitive(Byte... a)
```
    Converts an array of Bytes to an array of bytes. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the Byte array to convert.
    
    Returns:
    the corresponding byte array.
    
    Throws:
    
    NullPointerException - if a contains a null value.
  - toPrimitive
```
public static boolean[] toPrimitive(Boolean... a)
```
    Converts an array of Booleans to an array of booleans. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the Boolean array to convert.
    
    Returns:
    the corresponding boolean array.
    
    Throws:
    
    NullPointerException - if a contains a null value.
  - toPrimitive
```
public static float[] toPrimitive(Float... a)
```
    Converts an array of Floats to an array of floats. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the Float array to convert.
    
    Returns:
    the corresponding float array.
    
    Throws:
    
    NullPointerException - if a contains a null value.
  - toPrimitive
```
public static double[] toPrimitive(Double... a)
```
    Converts an array of Doubles to an array of doubles. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the Double array to convert.
    
    Returns:
    the corresponding double array.
    
    Throws:
    
    NullPointerException - if a contains a null value.
  - toObject
```
public static Long[] toObject(long... a)
```
    Converts an array of longs to an array of Longs. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the long array to convert.
    
    Returns:
    the corresponding Long array.
  - toObject
```
public static Integer[] toObject(int... a)
```
    Converts an array of ints to an array of Integers. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the int array to convert.
    
    Returns:
    the corresponding Integer array.
  - toObject
```
public static Short[] toObject(short... a)
```
    Converts an array of shorts to an array of Shorts. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the short array to convert.
    
    Returns:
    the corresponding Short array.
  - toObject
```
public static Character[] toObject(char... a)
```
    Converts an array of chars to an array of Characters. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the char array to convert.
    
    Returns:
    the corresponding Character array.
  - toObject
```
public static Byte[] toObject(byte... a)
```
    Converts an array of bytes to an array of Bytes. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the byte array to convert.
    
    Returns:
    the corresponding Byte array.
  - toObject
```
public static Boolean[] toObject(boolean... a)
```
    Converts an array of booleans to an array of Booleans. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the boolean array to convert.
    
    Returns:
    the corresponding Boolean array.
  - toObject
```
public static Float[] toObject(float... a)
```
    Converts an array of floats to an array of Floats. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the Float array to convert.
    
    Returns:
    the corresponding Short array.
  - toObject
```
public static Double[] toObject(double... a)
```
    Converts an array of doubles to an array of Doubles. Returns null if the given array is null. Does not modify the input array.
    
    Parameters:
    a - the double array to convert.
    
    Returns:
    the corresponding Double array.
  - toString
```
public static String toString(long... a)
```
    Returns a String representation of the contents of the given array. Returns "null" if a is null.
    
    Parameters:
    a - the array whose String representation to return.
    
    Returns:
    a String representation of a.
    See Also:
    Arrays.toString(long[])
  - toString
```
public static String toString(int... a)
```
    Returns a String representation of the contents of the given array. Returns "null" if a is null.
    
    Parameters:
    a - the array whose String representation to return.
    
    Returns:
    a String representation of a.
    See Also:
    Arrays.toString(int[])
  - toString
```
public static String toString(short... a)
```
    Returns a String representation of the contents of the given array. Returns "null" if a is null.
    
    Parameters:
    a - the array whose String representation to return.
    
    Returns:
    a String representation of a.
    See Also:
    Arrays.toString(short[])
  - toString
```
public static String toString(char... a)
```
    Returns a String representation of the contents of the given array. Returns "null" if a is null.
    
    Parameters:
    a - the array whose String representation to return.
    
    Returns:
    a String representation of a.
    See Also:
    Arrays.toString(char[])
  - toString
```
public static String toString(byte... a)
```
    Returns a String representation of the contents of the given array. Returns "null" if a is null.
    
    Parameters:
    a - the array whose String representation to return.
    
    Returns:
    a String representation of a.
    See Also:
    Arrays.toString(byte[])
  - toString
```
public static String toString(boolean... a)
```
    Returns a String representation of the contents of the given array. Returns "null" if a is null.
    
    Parameters:
    a - the array whose String representation to return.
    
    Returns:
    a String representation of a.
    See Also:
    Arrays.toString(boolean[])
  - toString
```
public static String toString(float... a)
```
    Returns a String representation of the contents of the given array. Returns "null" if a is null.
    
    Parameters:
    a - the array whose String representation to return.
    
    Returns:
    a String representation of a.
    See Also:
    Arrays.toString(float[])
  - toString
```
public static String toString(double... a)
```
    Returns a String representation of the contents of the given array. Returns "null" if a is null.
    
    Parameters:
    a - the array whose String representation to return.
    
    Returns:
    a String representation of a.
    See Also:
    Arrays.toString(double[])
  - toString
```
public static String toString(Object[] a)
```
    Returns a String representation of the contents of the given array. Accepts multidimensional arrays. Returns "null" if a is null.
    
    Parameters:
    a - the array whose String representation to return.
    
    Returns:
    a String representation of a.
    See Also:
    Arrays.deepToString(java.lang.Object[])

Class XArrays

Method Summary

Methods inherited from class java.lang.Object

Method Detail

isNullOrEmpty

isNullOrEmpty

isNullOrEmpty

isNullOrEmpty

isNullOrEmpty

isNullOrEmpty

isNullOrEmpty

isNullOrEmpty

isNullOrEmpty

concat

concat

concat

concat

concat

concat

concat

concat

concat

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

reverse

reverse

reverse

reverse

reverse

reverse

reverse

reverse

reverse

rotate

rotate

rotate

rotate

rotate

rotate

rotate

rotate

rotate

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

shuffle

sort

sort

sort

sort