java.lang.Object java.util.ArraysThis class contains various methods for manipulating arrays (such as sorting and searching). This class also contains a static factory that allows arrays to be viewed as lists.
The methods in this class all throw a {@code NullPointerException}, if the specified array reference is null, except where noted.
The documentation for the methods contained in this class includes briefs description of the implementations. Such descriptions should be regarded as implementation notes, rather than parts of the specification. Implementors should feel free to substitute other algorithms, so long as the specification itself is adhered to. (For example, the algorithm used by {@code sort(Object[])} does not have to be a MergeSort, but it does have to be stable.)
This class is a member of the Java Collections Framework.
Josh
 BlochNeal
 GafterJohn
 Rose1.2
 Nested Class Summary:  

static final class  Arrays.LegacyMergeSort  Old merge sort implementation can be selected (for compatibility with broken comparators) using a system property. Cannot be a static boolean in the enclosing class due to circular dependencies. To be removed in a future release. 
Methods from java.lang.Object: 

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait 
Method from java.util.Arrays Detail: 

public static List<T> asList(T a){ return new ArrayList< >(a); }
This method also provides a convenient way to create a fixedsize list initialized to contain several elements: List<String> stooges = Arrays.asList("Larry", "Moe", "Curly"); 
public static int binarySearch(long[] a, long key){ return binarySearch0(a, 0, a.length, key); }

public static int binarySearch(int[] a, int key){ return binarySearch0(a, 0, a.length, key); }

public static int binarySearch(short[] a, short key){ return binarySearch0(a, 0, a.length, key); }

public static int binarySearch(char[] a, char key){ return binarySearch0(a, 0, a.length, key); }

public static int binarySearch(byte[] a, byte key){ return binarySearch0(a, 0, a.length, key); }

public static int binarySearch(double[] a, double key){ return binarySearch0(a, 0, a.length, key); }

public static int binarySearch(float[] a, float key){ return binarySearch0(a, 0, a.length, key); }

public static int binarySearch(Object[] a, Object key){ return binarySearch0(a, 0, a.length, key); }

public static int binarySearch(T[] a, T key, Comparator<? super T> c){ return binarySearch0(a, 0, a.length, key, c); }

public static int binarySearch(long[] a, int fromIndex, int toIndex, long key){ rangeCheck(a.length, fromIndex, toIndex); return binarySearch0(a, fromIndex, toIndex, key); }

public static int binarySearch(int[] a, int fromIndex, int toIndex, int key){ rangeCheck(a.length, fromIndex, toIndex); return binarySearch0(a, fromIndex, toIndex, key); }

public static int binarySearch(short[] a, int fromIndex, int toIndex, short key){ rangeCheck(a.length, fromIndex, toIndex); return binarySearch0(a, fromIndex, toIndex, key); }

public static int binarySearch(char[] a, int fromIndex, int toIndex, char key){ rangeCheck(a.length, fromIndex, toIndex); return binarySearch0(a, fromIndex, toIndex, key); }

public static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key){ rangeCheck(a.length, fromIndex, toIndex); return binarySearch0(a, fromIndex, toIndex, key); }

public static int binarySearch(double[] a, int fromIndex, int toIndex, double key){ rangeCheck(a.length, fromIndex, toIndex); return binarySearch0(a, fromIndex, toIndex, key); }

public static int binarySearch(float[] a, int fromIndex, int toIndex, float key){ rangeCheck(a.length, fromIndex, toIndex); return binarySearch0(a, fromIndex, toIndex, key); }

public static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key){ rangeCheck(a.length, fromIndex, toIndex); return binarySearch0(a, fromIndex, toIndex, key); }

public static int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c){ rangeCheck(a.length, fromIndex, toIndex); return binarySearch0(a, fromIndex, toIndex, key, c); }

public static T[] copyOf(T[] original, int newLength){ return (T[]) copyOf(original, newLength, original.getClass()); }

public static byte[] copyOf(byte[] original, int newLength){ byte[] copy = new byte[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }

public static short[] copyOf(short[] original, int newLength){ short[] copy = new short[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }

public static int[] copyOf(int[] original, int newLength){ int[] copy = new int[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }

public static long[] copyOf(long[] original, int newLength){ long[] copy = new long[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }

public static char[] copyOf(char[] original, int newLength){ char[] copy = new char[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }

public static float[] copyOf(float[] original, int newLength){ float[] copy = new float[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }

public static double[] copyOf(double[] original, int newLength){ double[] copy = new double[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }

public static boolean[] copyOf(boolean[] original, int newLength){ boolean[] copy = new boolean[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }

public static T[] copyOf(U[] original, int newLength, Class<? extends T> newType){ T[] copy = ((Object)newType == (Object)Object[].class) ? (T[]) new Object[newLength] : (T[]) Array.newInstance(newType.getComponentType(), newLength); System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }

public static T[] copyOfRange(T[] original, int from, int to){ return copyOfRange(original, from, to, (Class< T[] >) original.getClass()); }
The resulting array is of exactly the same class as the original array. 
public static byte[] copyOfRange(byte[] original, int from, int to){ int newLength = to  from; if (newLength < 0) throw new IllegalArgumentException(from + " > " + to); byte[] copy = new byte[newLength]; System.arraycopy(original, from, copy, 0, Math.min(original.length  from, newLength)); return copy; }

public static short[] copyOfRange(short[] original, int from, int to){ int newLength = to  from; if (newLength < 0) throw new IllegalArgumentException(from + " > " + to); short[] copy = new short[newLength]; System.arraycopy(original, from, copy, 0, Math.min(original.length  from, newLength)); return copy; }

public static int[] copyOfRange(int[] original, int from, int to){ int newLength = to  from; if (newLength < 0) throw new IllegalArgumentException(from + " > " + to); int[] copy = new int[newLength]; System.arraycopy(original, from, copy, 0, Math.min(original.length  from, newLength)); return copy; }

public static long[] copyOfRange(long[] original, int from, int to){ int newLength = to  from; if (newLength < 0) throw new IllegalArgumentException(from + " > " + to); long[] copy = new long[newLength]; System.arraycopy(original, from, copy, 0, Math.min(original.length  from, newLength)); return copy; }

public static char[] copyOfRange(char[] original, int from, int to){ int newLength = to  from; if (newLength < 0) throw new IllegalArgumentException(from + " > " + to); char[] copy = new char[newLength]; System.arraycopy(original, from, copy, 0, Math.min(original.length  from, newLength)); return copy; }

public static float[] copyOfRange(float[] original, int from, int to){ int newLength = to  from; if (newLength < 0) throw new IllegalArgumentException(from + " > " + to); float[] copy = new float[newLength]; System.arraycopy(original, from, copy, 0, Math.min(original.length  from, newLength)); return copy; }

public static double[] copyOfRange(double[] original, int from, int to){ int newLength = to  from; if (newLength < 0) throw new IllegalArgumentException(from + " > " + to); double[] copy = new double[newLength]; System.arraycopy(original, from, copy, 0, Math.min(original.length  from, newLength)); return copy; }

public static boolean[] copyOfRange(boolean[] original, int from, int to){ int newLength = to  from; if (newLength < 0) throw new IllegalArgumentException(from + " > " + to); boolean[] copy = new boolean[newLength]; System.arraycopy(original, from, copy, 0, Math.min(original.length  from, newLength)); return copy; }

public static T[] copyOfRange(U[] original, int from, int to, Class<? extends T> newType){ int newLength = to  from; if (newLength < 0) throw new IllegalArgumentException(from + " > " + to); T[] copy = ((Object)newType == (Object)Object[].class) ? (T[]) new Object[newLength] : (T[]) Array.newInstance(newType.getComponentType(), newLength); System.arraycopy(original, from, copy, 0, Math.min(original.length  from, newLength)); return copy; }

public static boolean deepEquals(Object[] a1, Object[] a2){ if (a1 == a2) return true; if (a1 == null  a2==null) return false; int length = a1.length; if (a2.length != length) return false; for (int i = 0; i < length; i++) { Object e1 = a1[i]; Object e2 = a2[i]; if (e1 == e2) continue; if (e1 == null) return false; // Figure out whether the two elements are equal boolean eq = deepEquals0(e1, e2); if (!eq) return false; } return true; }
Two array references are considered deeply equal if both are null, or if they refer to arrays that contain the same number of elements and all corresponding pairs of elements in the two arrays are deeply equal. Two possibly null elements e1 and e2 are deeply equal if any of the following conditions hold: If either of the specified arrays contain themselves as elements either directly or indirectly through one or more levels of arrays, the behavior of this method is undefined. 
static boolean deepEquals0(Object e1, Object e2){ assert e1 != null; boolean eq; if (e1 instanceof Object[] && e2 instanceof Object[]) eq = deepEquals ((Object[]) e1, (Object[]) e2); else if (e1 instanceof byte[] && e2 instanceof byte[]) eq = equals((byte[]) e1, (byte[]) e2); else if (e1 instanceof short[] && e2 instanceof short[]) eq = equals((short[]) e1, (short[]) e2); else if (e1 instanceof int[] && e2 instanceof int[]) eq = equals((int[]) e1, (int[]) e2); else if (e1 instanceof long[] && e2 instanceof long[]) eq = equals((long[]) e1, (long[]) e2); else if (e1 instanceof char[] && e2 instanceof char[]) eq = equals((char[]) e1, (char[]) e2); else if (e1 instanceof float[] && e2 instanceof float[]) eq = equals((float[]) e1, (float[]) e2); else if (e1 instanceof double[] && e2 instanceof double[]) eq = equals((double[]) e1, (double[]) e2); else if (e1 instanceof boolean[] && e2 instanceof boolean[]) eq = equals((boolean[]) e1, (boolean[]) e2); else eq = e1.equals(e2); return eq; } 
public static int deepHashCode(Object[] a){ if (a == null) return 0; int result = 1; for (Object element : a) { int elementHash = 0; if (element instanceof Object[]) elementHash = deepHashCode((Object[]) element); else if (element instanceof byte[]) elementHash = hashCode((byte[]) element); else if (element instanceof short[]) elementHash = hashCode((short[]) element); else if (element instanceof int[]) elementHash = hashCode((int[]) element); else if (element instanceof long[]) elementHash = hashCode((long[]) element); else if (element instanceof char[]) elementHash = hashCode((char[]) element); else if (element instanceof float[]) elementHash = hashCode((float[]) element); else if (element instanceof double[]) elementHash = hashCode((double[]) element); else if (element instanceof boolean[]) elementHash = hashCode((boolean[]) element); else if (element != null) elementHash = element.hashCode(); result = 31 * result + elementHash; } return result; }
For any two arrays a and b such that Arrays.deepEquals(a, b), it is also the case that Arrays.deepHashCode(a) == Arrays.deepHashCode(b). The computation of the value returned by this method is similar to that of the value returned by List#hashCode() on a list containing the same elements as a in the same order, with one difference: If an element e of a is itself an array, its hash code is computed not by calling e.hashCode(), but as by calling the appropriate overloading of Arrays.hashCode(e) if e is an array of a primitive type, or as by calling Arrays.deepHashCode(e) recursively if e is an array of a reference type. If a is null, this method returns 0. 
public static String deepToString(Object[] a){ if (a == null) return "null"; int bufLen = 20 * a.length; if (a.length != 0 && bufLen < = 0) bufLen = Integer.MAX_VALUE; StringBuilder buf = new StringBuilder(bufLen); deepToString(a, buf, new HashSet< Object[] >()); return buf.toString(); }
The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Elements are converted to strings as by String.valueOf(Object), unless they are themselves arrays. If an element e is an array of a primitive type, it is converted to a string as by invoking the appropriate overloading of Arrays.toString(e). If an element e is an array of a reference type, it is converted to a string as by invoking this method recursively. To avoid infinite recursion, if the specified array contains itself as an element, or contains an indirect reference to itself through one or more levels of arrays, the selfreference is converted to the string "[...]". For example, an array containing only a reference to itself would be rendered as "[[...]]". This method returns "null" if the specified array is null. 
public static boolean equals(long[] a, long[] a2){ if (a==a2) return true; if (a==null  a2==null) return false; int length = a.length; if (a2.length != length) return false; for (int i=0; i< length; i++) if (a[i] != a2[i]) return false; return true; }

public static boolean equals(int[] a, int[] a2){ if (a==a2) return true; if (a==null  a2==null) return false; int length = a.length; if (a2.length != length) return false; for (int i=0; i< length; i++) if (a[i] != a2[i]) return false; return true; }

public static boolean equals(short[] a, short[] a2){ if (a==a2) return true; if (a==null  a2==null) return false; int length = a.length; if (a2.length != length) return false; for (int i=0; i< length; i++) if (a[i] != a2[i]) return false; return true; }

public static boolean equals(char[] a, char[] a2){ if (a==a2) return true; if (a==null  a2==null) return false; int length = a.length; if (a2.length != length) return false; for (int i=0; i< length; i++) if (a[i] != a2[i]) return false; return true; }

public static boolean equals(byte[] a, byte[] a2){ if (a==a2) return true; if (a==null  a2==null) return false; int length = a.length; if (a2.length != length) return false; for (int i=0; i< length; i++) if (a[i] != a2[i]) return false; return true; }

public static boolean equals(boolean[] a, boolean[] a2){ if (a==a2) return true; if (a==null  a2==null) return false; int length = a.length; if (a2.length != length) return false; for (int i=0; i< length; i++) if (a[i] != a2[i]) return false; return true; }

public static boolean equals(double[] a, double[] a2){ if (a==a2) return true; if (a==null  a2==null) return false; int length = a.length; if (a2.length != length) return false; for (int i=0; i< length; i++) if (Double.doubleToLongBits(a[i])!=Double.doubleToLongBits(a2[i])) return false; return true; }
Two doubles d1 and d2 are considered equal if: new Double(d1).equals(new Double(d2))(Unlike the == operator, this method considers NaN equals to itself, and 0.0d unequal to 0.0d.) 
public static boolean equals(float[] a, float[] a2){ if (a==a2) return true; if (a==null  a2==null) return false; int length = a.length; if (a2.length != length) return false; for (int i=0; i< length; i++) if (Float.floatToIntBits(a[i])!=Float.floatToIntBits(a2[i])) return false; return true; }
Two floats f1 and f2 are considered equal if: new Float(f1).equals(new Float(f2))(Unlike the == operator, this method considers NaN equals to itself, and 0.0f unequal to 0.0f.) 
public static boolean equals(Object[] a, Object[] a2){ if (a==a2) return true; if (a==null  a2==null) return false; int length = a.length; if (a2.length != length) return false; for (int i=0; i< length; i++) { Object o1 = a[i]; Object o2 = a2[i]; if (!(o1==null ? o2==null : o1.equals(o2))) return false; } return true; }

public static void fill(long[] a, long val){ for (int i = 0, len = a.length; i < len; i++) a[i] = val; }

public static void fill(int[] a, int val){ for (int i = 0, len = a.length; i < len; i++) a[i] = val; }

public static void fill(short[] a, short val){ for (int i = 0, len = a.length; i < len; i++) a[i] = val; }

public static void fill(char[] a, char val){ for (int i = 0, len = a.length; i < len; i++) a[i] = val; }

public static void fill(byte[] a, byte val){ for (int i = 0, len = a.length; i < len; i++) a[i] = val; }

public static void fill(boolean[] a, boolean val){ for (int i = 0, len = a.length; i < len; i++) a[i] = val; }

public static void fill(double[] a, double val){ for (int i = 0, len = a.length; i < len; i++) a[i] = val; }

public static void fill(float[] a, float val){ for (int i = 0, len = a.length; i < len; i++) a[i] = val; }

public static void fill(Object[] a, Object val){ for (int i = 0, len = a.length; i < len; i++) a[i] = val; }

public static void fill(long[] a, int fromIndex, int toIndex, long val){ rangeCheck(a.length, fromIndex, toIndex); for (int i = fromIndex; i < toIndex; i++) a[i] = val; }

public static void fill(int[] a, int fromIndex, int toIndex, int val){ rangeCheck(a.length, fromIndex, toIndex); for (int i = fromIndex; i < toIndex; i++) a[i] = val; }

public static void fill(short[] a, int fromIndex, int toIndex, short val){ rangeCheck(a.length, fromIndex, toIndex); for (int i = fromIndex; i < toIndex; i++) a[i] = val; }

public static void fill(char[] a, int fromIndex, int toIndex, char val){ rangeCheck(a.length, fromIndex, toIndex); for (int i = fromIndex; i < toIndex; i++) a[i] = val; }

public static void fill(byte[] a, int fromIndex, int toIndex, byte val){ rangeCheck(a.length, fromIndex, toIndex); for (int i = fromIndex; i < toIndex; i++) a[i] = val; }

public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val){ rangeCheck(a.length, fromIndex, toIndex); for (int i = fromIndex; i < toIndex; i++) a[i] = val; }

public static void fill(double[] a, int fromIndex, int toIndex, double val){ rangeCheck(a.length, fromIndex, toIndex); for (int i = fromIndex; i < toIndex; i++) a[i] = val; }

public static void fill(float[] a, int fromIndex, int toIndex, float val){ rangeCheck(a.length, fromIndex, toIndex); for (int i = fromIndex; i < toIndex; i++) a[i] = val; }

public static void fill(Object[] a, int fromIndex, int toIndex, Object val){ rangeCheck(a.length, fromIndex, toIndex); for (int i = fromIndex; i < toIndex; i++) a[i] = val; }

public static int hashCode(long[] a){ if (a == null) return 0; int result = 1; for (long element : a) { int elementHash = (int)(element ^ (element > > > 32)); result = 31 * result + elementHash; } return result; }
The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of Long instances representing the elements of a in the same order. If a is null, this method returns 0. 
public static int hashCode(int[] a){ if (a == null) return 0; int result = 1; for (int element : a) result = 31 * result + element; return result; }
The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of Integer instances representing the elements of a in the same order. If a is null, this method returns 0. 
public static int hashCode(short[] a){ if (a == null) return 0; int result = 1; for (short element : a) result = 31 * result + element; return result; }
The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of Short instances representing the elements of a in the same order. If a is null, this method returns 0. 
public static int hashCode(char[] a){ if (a == null) return 0; int result = 1; for (char element : a) result = 31 * result + element; return result; }
The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of Character instances representing the elements of a in the same order. If a is null, this method returns 0. 
public static int hashCode(byte[] a){ if (a == null) return 0; int result = 1; for (byte element : a) result = 31 * result + element; return result; }
The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of Byte instances representing the elements of a in the same order. If a is null, this method returns 0. 
public static int hashCode(boolean[] a){ if (a == null) return 0; int result = 1; for (boolean element : a) result = 31 * result + (element ? 1231 : 1237); return result; }
The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of Boolean instances representing the elements of a in the same order. If a is null, this method returns 0. 
public static int hashCode(float[] a){ if (a == null) return 0; int result = 1; for (float element : a) result = 31 * result + Float.floatToIntBits(element); return result; }
The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of Float instances representing the elements of a in the same order. If a is null, this method returns 0. 
public static int hashCode(double[] a){ if (a == null) return 0; int result = 1; for (double element : a) { long bits = Double.doubleToLongBits(element); result = 31 * result + (int)(bits ^ (bits > > > 32)); } return result; }
The value returned by this method is the same value that would be obtained by invoking the hashCode method on a List containing a sequence of Double instances representing the elements of a in the same order. If a is null, this method returns 0. 
public static int hashCode(Object[] a){ if (a == null) return 0; int result = 1; for (Object element : a) result = 31 * result + (element == null ? 0 : element.hashCode()); return result; }
For any two arrays a and b such that Arrays.equals(a, b), it is also the case that Arrays.hashCode(a) == Arrays.hashCode(b). The value returned by this method is equal to the value that would be returned by Arrays.asList(a).hashCode(), unless a is null, in which case 0 is returned. 
public static void sort(int[] a){ DualPivotQuicksort.sort(a); }
Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(long[] a){ DualPivotQuicksort.sort(a); }
Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(short[] a){ DualPivotQuicksort.sort(a); }
Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(char[] a){ DualPivotQuicksort.sort(a); }
Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(byte[] a){ DualPivotQuicksort.sort(a); }
Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(float[] a){ DualPivotQuicksort.sort(a); }
The {@code <} relation does not provide a total order on all float values: {@code 0.0f == 0.0f} is {@code true} and a {@code Float.NaN} value compares neither less than, greater than, nor equal to any value, even itself. This method uses the total order imposed by the method Float#compareTo : {@code 0.0f} is treated as less than value {@code 0.0f} and {@code Float.NaN} is considered greater than any other value and all {@code Float.NaN} values are considered equal. Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(double[] a){ DualPivotQuicksort.sort(a); }
The {@code <} relation does not provide a total order on all double values: {@code 0.0d == 0.0d} is {@code true} and a {@code Double.NaN} value compares neither less than, greater than, nor equal to any value, even itself. This method uses the total order imposed by the method Double#compareTo : {@code 0.0d} is treated as less than value {@code 0.0d} and {@code Double.NaN} is considered greater than any other value and all {@code Double.NaN} values are considered equal. Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(Object[] a){ if (LegacyMergeSort.userRequested) legacyMergeSort(a); else ComparableTimSort.sort(a); }
This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort. Implementation note: This implementation is a stable, adaptive, iterative mergesort that requires far fewer than n lg(n) comparisons when the input array is partially sorted, while offering the performance of a traditional mergesort when the input array is randomly ordered. If the input array is nearly sorted, the implementation requires approximately n comparisons. Temporary storage requirements vary from a small constant for nearly sorted input arrays to n/2 object references for randomly ordered input arrays. The implementation takes equal advantage of ascending and descending order in its input array, and can take advantage of ascending and descending order in different parts of the the same input array. It is wellsuited to merging two or more sorted arrays: simply concatenate the arrays and sort the resulting array. The implementation was adapted from Tim Peters's list sort for Python ( TimSort). It uses techiques from Peter McIlroy's "Optimistic Sorting and Information Theoretic Complexity", in Proceedings of the Fourth Annual ACMSIAM Symposium on Discrete Algorithms, pp 467474, January 1993. 
public static void sort(T[] a, Comparator<? super T> c){ if (LegacyMergeSort.userRequested) legacyMergeSort(a, c); else TimSort.sort(a, c); }
This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort. Implementation note: This implementation is a stable, adaptive, iterative mergesort that requires far fewer than n lg(n) comparisons when the input array is partially sorted, while offering the performance of a traditional mergesort when the input array is randomly ordered. If the input array is nearly sorted, the implementation requires approximately n comparisons. Temporary storage requirements vary from a small constant for nearly sorted input arrays to n/2 object references for randomly ordered input arrays. The implementation takes equal advantage of ascending and descending order in its input array, and can take advantage of ascending and descending order in different parts of the the same input array. It is wellsuited to merging two or more sorted arrays: simply concatenate the arrays and sort the resulting array. The implementation was adapted from Tim Peters's list sort for Python ( TimSort). It uses techiques from Peter McIlroy's "Optimistic Sorting and Information Theoretic Complexity", in Proceedings of the Fourth Annual ACMSIAM Symposium on Discrete Algorithms, pp 467474, January 1993. 
public static void sort(int[] a, int fromIndex, int toIndex){ rangeCheck(a.length, fromIndex, toIndex); DualPivotQuicksort.sort(a, fromIndex, toIndex  1); }
Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(long[] a, int fromIndex, int toIndex){ rangeCheck(a.length, fromIndex, toIndex); DualPivotQuicksort.sort(a, fromIndex, toIndex  1); }
Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(short[] a, int fromIndex, int toIndex){ rangeCheck(a.length, fromIndex, toIndex); DualPivotQuicksort.sort(a, fromIndex, toIndex  1); }
Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(char[] a, int fromIndex, int toIndex){ rangeCheck(a.length, fromIndex, toIndex); DualPivotQuicksort.sort(a, fromIndex, toIndex  1); }
Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(byte[] a, int fromIndex, int toIndex){ rangeCheck(a.length, fromIndex, toIndex); DualPivotQuicksort.sort(a, fromIndex, toIndex  1); }
Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(float[] a, int fromIndex, int toIndex){ rangeCheck(a.length, fromIndex, toIndex); DualPivotQuicksort.sort(a, fromIndex, toIndex  1); }
The {@code <} relation does not provide a total order on all float values: {@code 0.0f == 0.0f} is {@code true} and a {@code Float.NaN} value compares neither less than, greater than, nor equal to any value, even itself. This method uses the total order imposed by the method Float#compareTo : {@code 0.0f} is treated as less than value {@code 0.0f} and {@code Float.NaN} is considered greater than any other value and all {@code Float.NaN} values are considered equal. Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(double[] a, int fromIndex, int toIndex){ rangeCheck(a.length, fromIndex, toIndex); DualPivotQuicksort.sort(a, fromIndex, toIndex  1); }
The {@code <} relation does not provide a total order on all double values: {@code 0.0d == 0.0d} is {@code true} and a {@code Double.NaN} value compares neither less than, greater than, nor equal to any value, even itself. This method uses the total order imposed by the method Double#compareTo : {@code 0.0d} is treated as less than value {@code 0.0d} and {@code Double.NaN} is considered greater than any other value and all {@code Double.NaN} values are considered equal. Implementation note: The sorting algorithm is a DualPivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (onepivot) Quicksort implementations. 
public static void sort(Object[] a, int fromIndex, int toIndex){ if (LegacyMergeSort.userRequested) legacyMergeSort(a, fromIndex, toIndex); else ComparableTimSort.sort(a, fromIndex, toIndex); }
This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort. Implementation note: This implementation is a stable, adaptive, iterative mergesort that requires far fewer than n lg(n) comparisons when the input array is partially sorted, while offering the performance of a traditional mergesort when the input array is randomly ordered. If the input array is nearly sorted, the implementation requires approximately n comparisons. Temporary storage requirements vary from a small constant for nearly sorted input arrays to n/2 object references for randomly ordered input arrays. The implementation takes equal advantage of ascending and descending order in its input array, and can take advantage of ascending and descending order in different parts of the the same input array. It is wellsuited to merging two or more sorted arrays: simply concatenate the arrays and sort the resulting array. The implementation was adapted from Tim Peters's list sort for Python ( TimSort). It uses techiques from Peter McIlroy's "Optimistic Sorting and Information Theoretic Complexity", in Proceedings of the Fourth Annual ACMSIAM Symposium on Discrete Algorithms, pp 467474, January 1993. 
public static void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c){ if (LegacyMergeSort.userRequested) legacyMergeSort(a, fromIndex, toIndex, c); else TimSort.sort(a, fromIndex, toIndex, c); }
This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort. Implementation note: This implementation is a stable, adaptive, iterative mergesort that requires far fewer than n lg(n) comparisons when the input array is partially sorted, while offering the performance of a traditional mergesort when the input array is randomly ordered. If the input array is nearly sorted, the implementation requires approximately n comparisons. Temporary storage requirements vary from a small constant for nearly sorted input arrays to n/2 object references for randomly ordered input arrays. The implementation takes equal advantage of ascending and descending order in its input array, and can take advantage of ascending and descending order in different parts of the the same input array. It is wellsuited to merging two or more sorted arrays: simply concatenate the arrays and sort the resulting array. The implementation was adapted from Tim Peters's list sort for Python ( TimSort). It uses techiques from Peter McIlroy's "Optimistic Sorting and Information Theoretic Complexity", in Proceedings of the Fourth Annual ACMSIAM Symposium on Discrete Algorithms, pp 467474, January 1993. 
public static String toString(long[] a){ if (a == null) return "null"; int iMax = a.length  1; if (iMax == 1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(a[i]); if (i == iMax) return b.append(']').toString(); b.append(", "); } }

public static String toString(int[] a){ if (a == null) return "null"; int iMax = a.length  1; if (iMax == 1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(a[i]); if (i == iMax) return b.append(']').toString(); b.append(", "); } }

public static String toString(short[] a){ if (a == null) return "null"; int iMax = a.length  1; if (iMax == 1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(a[i]); if (i == iMax) return b.append(']').toString(); b.append(", "); } }

public static String toString(char[] a){ if (a == null) return "null"; int iMax = a.length  1; if (iMax == 1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(a[i]); if (i == iMax) return b.append(']').toString(); b.append(", "); } }

public static String toString(byte[] a){ if (a == null) return "null"; int iMax = a.length  1; if (iMax == 1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(a[i]); if (i == iMax) return b.append(']').toString(); b.append(", "); } }

public static String toString(boolean[] a){ if (a == null) return "null"; int iMax = a.length  1; if (iMax == 1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(a[i]); if (i == iMax) return b.append(']').toString(); b.append(", "); } }

public static String toString(float[] a){ if (a == null) return "null"; int iMax = a.length  1; if (iMax == 1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(a[i]); if (i == iMax) return b.append(']').toString(); b.append(", "); } }

public static String toString(double[] a){ if (a == null) return "null"; int iMax = a.length  1; if (iMax == 1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(a[i]); if (i == iMax) return b.append(']').toString(); b.append(", "); } }

public static String toString(Object[] a){ if (a == null) return "null"; int iMax = a.length  1; if (iMax == 1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(String.valueOf(a[i])); if (i == iMax) return b.append(']').toString(); b.append(", "); } }
The value returned by this method is equal to the value that would be returned by Arrays.asList(a).toString(), unless a is null, in which case "null" is returned. 