Arrays

java.lang.Object
- java.util.Arrays

```
public class Arrays
extends Object
```
This class contains various static utility methods performing operations on arrays, and a method to provide a List "view" of an array to facilitate using arrays with Collection-based APIs. All methods throw a NullPointerException if the parameter array is null.
Implementations may use their own algorithms, but must obey the general properties; for example, the sort must be stable and n*log(n) complexity. Sun's implementation of sort, and therefore ours, is a tuned quicksort, adapted from Jon L. Bentley and M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P. 1249-1265 (November 1993). This algorithm offers n*log(n) performance on many data sets that cause other quicksorts to degrade to quadratic performance.

Since:

1.2

Author:

Original author unknown, Bryce McKinlay, Eric Blake

See Also:

Comparable, Comparator

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static List`	`asList(Object[] a)` Returns a list "view" of the specified array.
`static int`	`binarySearch(byte[] a, byte key)` Perform a binary search of a byte array for a key.
`static int`	`binarySearch(char[] a, char key)` Perform a binary search of a char array for a key.
`static int`	`binarySearch(double[] a, double key)` Perform a binary search of a double array for a key.
`static int`	`binarySearch(float[] a, float key)` Perform a binary search of a float array for a key.
`static int`	`binarySearch(int[] a, int key)` Perform a binary search of an int array for a key.
`static int`	`binarySearch(long[] a, long key)` Perform a binary search of a long array for a key.
`static int`	`binarySearch(Object[] a, Object key)` Perform a binary search of an Object array for a key, using the natural ordering of the elements.
`static int`	`binarySearch(Object[] a, Object key, Comparator c)` Perform a binary search of an Object array for a key, using a supplied Comparator.
`static int`	`binarySearch(short[] a, short key)` Perform a binary search of a short array for a key.
`static boolean`	`equals(boolean[] a1, boolean[] a2)` Compare two boolean arrays for equality.
`static boolean`	`equals(byte[] a1, byte[] a2)` Compare two byte arrays for equality.
`static boolean`	`equals(char[] a1, char[] a2)` Compare two char arrays for equality.
`static boolean`	`equals(double[] a1, double[] a2)` Compare two double arrays for equality.
`static boolean`	`equals(float[] a1, float[] a2)` Compare two float arrays for equality.
`static boolean`	`equals(int[] a1, int[] a2)` Compare two int arrays for equality.
`static boolean`	`equals(long[] a1, long[] a2)` Compare two long arrays for equality.
`static boolean`	`equals(Object[] a1, Object[] a2)` Compare two Object arrays for equality.
`static boolean`	`equals(short[] a1, short[] a2)` Compare two short arrays for equality.
`static void`	`fill(boolean[] a, boolean val)` Fill an array with a boolean value.
`static void`	`fill(boolean[] a, int fromIndex, int toIndex, boolean val)` Fill a range of an array with a boolean value.
`static void`	`fill(byte[] a, byte val)` Fill an array with a byte value.
`static void`	`fill(byte[] a, int fromIndex, int toIndex, byte val)` Fill a range of an array with a byte value.
`static void`	`fill(char[] a, char val)` Fill an array with a char value.
`static void`	`fill(char[] a, int fromIndex, int toIndex, char val)` Fill a range of an array with a char value.
`static void`	`fill(double[] a, double val)` Fill an array with a double value.
`static void`	`fill(double[] a, int fromIndex, int toIndex, double val)` Fill a range of an array with a double value.
`static void`	`fill(float[] a, float val)` Fill an array with a float value.
`static void`	`fill(float[] a, int fromIndex, int toIndex, float val)` Fill a range of an array with a float value.
`static void`	`fill(int[] a, int val)` Fill an array with an int value.
`static void`	`fill(int[] a, int fromIndex, int toIndex, int val)` Fill a range of an array with an int value.
`static void`	`fill(long[] a, int fromIndex, int toIndex, long val)` Fill a range of an array with a long value.
`static void`	`fill(long[] a, long val)` Fill an array with a long value.
`static void`	`fill(Object[] a, int fromIndex, int toIndex, Object val)` Fill a range of an array with an Object value.
`static void`	`fill(Object[] a, Object val)` Fill an array with an Object value.
`static void`	`fill(short[] a, int fromIndex, int toIndex, short val)` Fill a range of an array with a short value.
`static void`	`fill(short[] a, short val)` Fill an array with a short value.
`static void`	`sort(byte[] a)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(byte[] a, int fromIndex, int toIndex)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(char[] a)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(char[] a, int fromIndex, int toIndex)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(double[] a)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(double[] a, int fromIndex, int toIndex)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(float[] a)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(float[] a, int fromIndex, int toIndex)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(int[] a)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(int[] a, int fromIndex, int toIndex)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(long[] a)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(long[] a, int fromIndex, int toIndex)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(Object[] a)` Sort an array of Objects according to their natural ordering.
`static void`	`sort(Object[] a, Comparator c)` Sort an array of Objects according to a Comparator.
`static void`	`sort(Object[] a, int fromIndex, int toIndex)` Sort an array of Objects according to their natural ordering.
`static void`	`sort(Object[] a, int fromIndex, int toIndex, Comparator c)` Sort an array of Objects according to a Comparator.
`static void`	`sort(short[] a)` Performs a stable sort on the elements, arranging them according to their natural order.
`static void`	`sort(short[] a, int fromIndex, int toIndex)` Performs a stable sort on the elements, arranging them according to their natural order.

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

- Method Detail
  - binarySearch
```
public static int binarySearch(byte[] a,
                               byte key)
```
    Perform a binary search of a byte array for a key. The array must be sorted (as by the sort() method) - if it is not, the behaviour of this method is undefined, and may be an infinite loop. If the array contains the key more than once, any one of them may be found. Note: although the specification allows for an infinite loop if the array is unsorted, it will not happen in this implementation.
    
    Parameters:
    
    a - the array to search (must be sorted)
    
    key - the value to search for
    
    Returns:
    
    the index at which the key was found, or -n-1 if it was not found, where n is the index of the first value higher than key or a.length if there is no such value.
  - binarySearch
```
public static int binarySearch(char[] a,
                               char key)
```
    Perform a binary search of a char array for a key. The array must be sorted (as by the sort() method) - if it is not, the behaviour of this method is undefined, and may be an infinite loop. If the array contains the key more than once, any one of them may be found. Note: although the specification allows for an infinite loop if the array is unsorted, it will not happen in this implementation.
    
    Parameters:
    
    a - the array to search (must be sorted)
    
    key - the value to search for
    
    Returns:
    
    the index at which the key was found, or -n-1 if it was not found, where n is the index of the first value higher than key or a.length if there is no such value.
  - binarySearch
```
public static int binarySearch(short[] a,
                               short key)
```
    Perform a binary search of a short array for a key. The array must be sorted (as by the sort() method) - if it is not, the behaviour of this method is undefined, and may be an infinite loop. If the array contains the key more than once, any one of them may be found. Note: although the specification allows for an infinite loop if the array is unsorted, it will not happen in this implementation.
    
    Parameters:
    
    a - the array to search (must be sorted)
    
    key - the value to search for
    
    Returns:
    
    the index at which the key was found, or -n-1 if it was not found, where n is the index of the first value higher than key or a.length if there is no such value.
  - binarySearch
```
public static int binarySearch(int[] a,
                               int key)
```
    Perform a binary search of an int array for a key. The array must be sorted (as by the sort() method) - if it is not, the behaviour of this method is undefined, and may be an infinite loop. If the array contains the key more than once, any one of them may be found. Note: although the specification allows for an infinite loop if the array is unsorted, it will not happen in this implementation.
    
    Parameters:
    
    a - the array to search (must be sorted)
    
    key - the value to search for
    
    Returns:
    
    the index at which the key was found, or -n-1 if it was not found, where n is the index of the first value higher than key or a.length if there is no such value.
  - binarySearch
```
public static int binarySearch(long[] a,
                               long key)
```
    Perform a binary search of a long array for a key. The array must be sorted (as by the sort() method) - if it is not, the behaviour of this method is undefined, and may be an infinite loop. If the array contains the key more than once, any one of them may be found. Note: although the specification allows for an infinite loop if the array is unsorted, it will not happen in this implementation.
    
    Parameters:
    
    a - the array to search (must be sorted)
    
    key - the value to search for
    
    Returns:
    
    the index at which the key was found, or -n-1 if it was not found, where n is the index of the first value higher than key or a.length if there is no such value.
  - binarySearch
```
public static int binarySearch(float[] a,
                               float key)
```
    Perform a binary search of a float array for a key. The array must be sorted (as by the sort() method) - if it is not, the behaviour of this method is undefined, and may be an infinite loop. If the array contains the key more than once, any one of them may be found. Note: although the specification allows for an infinite loop if the array is unsorted, it will not happen in this implementation.
    
    Parameters:
    
    a - the array to search (must be sorted)
    
    key - the value to search for
    
    Returns:
    
    the index at which the key was found, or -n-1 if it was not found, where n is the index of the first value higher than key or a.length if there is no such value.
  - binarySearch
```
public static int binarySearch(double[] a,
                               double key)
```
    Perform a binary search of a double array for a key. The array must be sorted (as by the sort() method) - if it is not, the behaviour of this method is undefined, and may be an infinite loop. If the array contains the key more than once, any one of them may be found. Note: although the specification allows for an infinite loop if the array is unsorted, it will not happen in this implementation.
    
    Parameters:
    
    a - the array to search (must be sorted)
    
    key - the value to search for
    
    Returns:
    
    the index at which the key was found, or -n-1 if it was not found, where n is the index of the first value higher than key or a.length if there is no such value.
  - binarySearch
```
public static int binarySearch(Object[] a,
                               Object key)
```
    Perform a binary search of an Object array for a key, using the natural ordering of the elements. The array must be sorted (as by the sort() method) - if it is not, the behaviour of this method is undefined, and may be an infinite loop. Further, the key must be comparable with every item in the array. If the array contains the key more than once, any one of them may be found. Note: although the specification allows for an infinite loop if the array is unsorted, it will not happen in this (JCL) implementation.
    
    Parameters:
    
    a - the array to search (must be sorted)
    
    key - the value to search for
    
    Returns:
    
    the index at which the key was found, or -n-1 if it was not found, where n is the index of the first value higher than key or a.length if there is no such value.
    
    Throws:
    
    ClassCastException - if key could not be compared with one of the elements of a
    
    NullPointerException - if a null element in a is compared
  - binarySearch
```
public static int binarySearch(Object[] a,
                               Object key,
                               Comparator c)
```
    Perform a binary search of an Object array for a key, using a supplied Comparator. The array must be sorted (as by the sort() method with the same Comparator) - if it is not, the behaviour of this method is undefined, and may be an infinite loop. Further, the key must be comparable with every item in the array. If the array contains the key more than once, any one of them may be found. Note: although the specification allows for an infinite loop if the array is unsorted, it will not happen in this (JCL) implementation.
    
    Parameters:
    
    a - the array to search (must be sorted)
    
    key - the value to search for
    
    c - the comparator by which the array is sorted; or null to use the elements' natural order
    
    Returns:
    
    the index at which the key was found, or -n-1 if it was not found, where n is the index of the first value higher than key or a.length if there is no such value.
    
    Throws:
    
    ClassCastException - if key could not be compared with one of the elements of a
    
    NullPointerException - if a null element is compared with natural ordering (only possible when c is null)
  - equals
```
public static boolean equals(boolean[] a1,
                             boolean[] a2)
```
    Compare two boolean arrays for equality.
    
    Parameters:
    
    a1 - the first array to compare
    
    a2 - the second array to compare
    
    Returns:
    
    true if a1 and a2 are both null, or if a2 is of the same length as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
  - equals
```
public static boolean equals(byte[] a1,
                             byte[] a2)
```
    Compare two byte arrays for equality.
    
    Parameters:
    
    a1 - the first array to compare
    
    a2 - the second array to compare
    
    Returns:
    
    true if a1 and a2 are both null, or if a2 is of the same length as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
  - equals
```
public static boolean equals(char[] a1,
                             char[] a2)
```
    Compare two char arrays for equality.
    
    Parameters:
    
    a1 - the first array to compare
    
    a2 - the second array to compare
    
    Returns:
    
    true if a1 and a2 are both null, or if a2 is of the same length as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
  - equals
```
public static boolean equals(short[] a1,
                             short[] a2)
```
    Compare two short arrays for equality.
    
    Parameters:
    
    a1 - the first array to compare
    
    a2 - the second array to compare
    
    Returns:
    
    true if a1 and a2 are both null, or if a2 is of the same length as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
  - equals
```
public static boolean equals(int[] a1,
                             int[] a2)
```
    Compare two int arrays for equality.
    
    Parameters:
    
    a1 - the first array to compare
    
    a2 - the second array to compare
    
    Returns:
    
    true if a1 and a2 are both null, or if a2 is of the same length as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
  - equals
```
public static boolean equals(long[] a1,
                             long[] a2)
```
    Compare two long arrays for equality.
    
    Parameters:
    
    a1 - the first array to compare
    
    a2 - the second array to compare
    
    Returns:
    
    true if a1 and a2 are both null, or if a2 is of the same length as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
  - equals
```
public static boolean equals(float[] a1,
                             float[] a2)
```
    Compare two float arrays for equality.
    
    Parameters:
    
    a1 - the first array to compare
    
    a2 - the second array to compare
    
    Returns:
    
    true if a1 and a2 are both null, or if a2 is of the same length as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
  - equals
```
public static boolean equals(double[] a1,
                             double[] a2)
```
    Compare two double arrays for equality.
    
    Parameters:
    
    a1 - the first array to compare
    
    a2 - the second array to compare
    
    Returns:
    
    true if a1 and a2 are both null, or if a2 is of the same length as a1, and for each 0 <= i < a1.length, a1[i] == a2[i]
  - equals
```
public static boolean equals(Object[] a1,
                             Object[] a2)
```
    Compare two Object arrays for equality.
    
    Parameters:
    
    a1 - the first array to compare
    
    a2 - the second array to compare
    
    Returns:
    
    true if a1 and a2 are both null, or if a1 is of the same length as a2, and for each 0 <= i < a.length, a1[i] == null ? a2[i] == null : a1[i].equals(a2[i]).
  - fill
```
public static void fill(boolean[] a,
                        boolean val)
```
    Fill an array with a boolean value.
    
    Parameters:
    
    a - the array to fill
    
    val - the value to fill it with
  - fill
```
public static void fill(boolean[] a,
                        int fromIndex,
                        int toIndex,
                        boolean val)
```
    Fill a range of an array with a boolean value.
    
    Parameters:
    
    a - the array to fill
    
    fromIndex - the index to fill from, inclusive
    
    toIndex - the index to fill to, exclusive
    
    val - the value to fill with
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - fill
```
public static void fill(byte[] a,
                        byte val)
```
    Fill an array with a byte value.
    
    Parameters:
    
    a - the array to fill
    
    val - the value to fill it with
  - fill
```
public static void fill(byte[] a,
                        int fromIndex,
                        int toIndex,
                        byte val)
```
    Fill a range of an array with a byte value.
    
    Parameters:
    
    a - the array to fill
    
    fromIndex - the index to fill from, inclusive
    
    toIndex - the index to fill to, exclusive
    
    val - the value to fill with
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - fill
```
public static void fill(char[] a,
                        char val)
```
    Fill an array with a char value.
    
    Parameters:
    
    a - the array to fill
    
    val - the value to fill it with
  - fill
```
public static void fill(char[] a,
                        int fromIndex,
                        int toIndex,
                        char val)
```
    Fill a range of an array with a char value.
    
    Parameters:
    
    a - the array to fill
    
    fromIndex - the index to fill from, inclusive
    
    toIndex - the index to fill to, exclusive
    
    val - the value to fill with
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - fill
```
public static void fill(short[] a,
                        short val)
```
    Fill an array with a short value.
    
    Parameters:
    
    a - the array to fill
    
    val - the value to fill it with
  - fill
```
public static void fill(short[] a,
                        int fromIndex,
                        int toIndex,
                        short val)
```
    Fill a range of an array with a short value.
    
    Parameters:
    
    a - the array to fill
    
    fromIndex - the index to fill from, inclusive
    
    toIndex - the index to fill to, exclusive
    
    val - the value to fill with
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - fill
```
public static void fill(int[] a,
                        int val)
```
    Fill an array with an int value.
    
    Parameters:
    
    a - the array to fill
    
    val - the value to fill it with
  - fill
```
public static void fill(int[] a,
                        int fromIndex,
                        int toIndex,
                        int val)
```
    Fill a range of an array with an int value.
    
    Parameters:
    
    a - the array to fill
    
    fromIndex - the index to fill from, inclusive
    
    toIndex - the index to fill to, exclusive
    
    val - the value to fill with
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - fill
```
public static void fill(long[] a,
                        long val)
```
    Fill an array with a long value.
    
    Parameters:
    
    a - the array to fill
    
    val - the value to fill it with
  - fill
```
public static void fill(long[] a,
                        int fromIndex,
                        int toIndex,
                        long val)
```
    Fill a range of an array with a long value.
    
    Parameters:
    
    a - the array to fill
    
    fromIndex - the index to fill from, inclusive
    
    toIndex - the index to fill to, exclusive
    
    val - the value to fill with
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - fill
```
public static void fill(float[] a,
                        float val)
```
    Fill an array with a float value.
    
    Parameters:
    
    a - the array to fill
    
    val - the value to fill it with
  - fill
```
public static void fill(float[] a,
                        int fromIndex,
                        int toIndex,
                        float val)
```
    Fill a range of an array with a float value.
    
    Parameters:
    
    a - the array to fill
    
    fromIndex - the index to fill from, inclusive
    
    toIndex - the index to fill to, exclusive
    
    val - the value to fill with
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - fill
```
public static void fill(double[] a,
                        double val)
```
    Fill an array with a double value.
    
    Parameters:
    
    a - the array to fill
    
    val - the value to fill it with
  - fill
```
public static void fill(double[] a,
                        int fromIndex,
                        int toIndex,
                        double val)
```
    Fill a range of an array with a double value.
    
    Parameters:
    
    a - the array to fill
    
    fromIndex - the index to fill from, inclusive
    
    toIndex - the index to fill to, exclusive
    
    val - the value to fill with
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - fill
```
public static void fill(Object[] a,
                        Object val)
```
    Fill an array with an Object value.
    
    Parameters:
    
    a - the array to fill
    
    val - the value to fill it with
    
    Throws:
    
    ClassCastException - if val is not an instance of the element type of a.
  - fill
```
public static void fill(Object[] a,
                        int fromIndex,
                        int toIndex,
                        Object val)
```
    Fill a range of an array with an Object value.
    
    Parameters:
    
    a - the array to fill
    
    fromIndex - the index to fill from, inclusive
    
    toIndex - the index to fill to, exclusive
    
    val - the value to fill with
    
    Throws:
    
    ClassCastException - if val is not an instance of the element type of a.
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - sort
```
public static void sort(byte[] a)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the byte array to sort
  - sort
```
public static void sort(byte[] a,
                        int fromIndex,
                        int toIndex)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the byte array to sort
    
    fromIndex - the first index to sort (inclusive)
    
    toIndex - the last index to sort (exclusive)
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - sort
```
public static void sort(char[] a)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the char array to sort
  - sort
```
public static void sort(char[] a,
                        int fromIndex,
                        int toIndex)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the char array to sort
    
    fromIndex - the first index to sort (inclusive)
    
    toIndex - the last index to sort (exclusive)
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - sort
```
public static void sort(short[] a)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the short array to sort
  - sort
```
public static void sort(short[] a,
                        int fromIndex,
                        int toIndex)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the short array to sort
    
    fromIndex - the first index to sort (inclusive)
    
    toIndex - the last index to sort (exclusive)
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - sort
```
public static void sort(int[] a)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the int array to sort
  - sort
```
public static void sort(int[] a,
                        int fromIndex,
                        int toIndex)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the int array to sort
    
    fromIndex - the first index to sort (inclusive)
    
    toIndex - the last index to sort (exclusive)
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - sort
```
public static void sort(long[] a)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the long array to sort
  - sort
```
public static void sort(long[] a,
                        int fromIndex,
                        int toIndex)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the long array to sort
    
    fromIndex - the first index to sort (inclusive)
    
    toIndex - the last index to sort (exclusive)
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - sort
```
public static void sort(float[] a)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the float array to sort
  - sort
```
public static void sort(float[] a,
                        int fromIndex,
                        int toIndex)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the float array to sort
    
    fromIndex - the first index to sort (inclusive)
    
    toIndex - the last index to sort (exclusive)
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - sort
```
public static void sort(double[] a)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the double array to sort
  - sort
```
public static void sort(double[] a,
                        int fromIndex,
                        int toIndex)
```
    Performs a stable sort on the elements, arranging them according to their natural order.
    
    Parameters:
    
    a - the double array to sort
    
    fromIndex - the first index to sort (inclusive)
    
    toIndex - the last index to sort (exclusive)
    
    Throws:
    
    IllegalArgumentException - if fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - if fromIndex < 0 || toIndex > a.length
  - sort
```
public static void sort(Object[] a)
```
    Sort an array of Objects according to their natural ordering. The sort is guaranteed to be stable, that is, equal elements will not be reordered. The sort algorithm is a mergesort with the merge omitted if the last element of one half comes before the first element of the other half. This algorithm gives guaranteed O(n*log(n)) time, at the expense of making a copy of the array.
    
    Parameters:
    
    a - the array to be sorted
    
    Throws:
    
    ClassCastException - if any two elements are not mutually comparable
    
    NullPointerException - if an element is null (since null.compareTo cannot work)
    
    See Also:
    
    Comparable
  - sort
```
public static void sort(Object[] a,
                        Comparator c)
```
    Sort an array of Objects according to a Comparator. The sort is guaranteed to be stable, that is, equal elements will not be reordered. The sort algorithm is a mergesort with the merge omitted if the last element of one half comes before the first element of the other half. This algorithm gives guaranteed O(n*log(n)) time, at the expense of making a copy of the array.
    
    Parameters:
    
    a - the array to be sorted
    
    c - a Comparator to use in sorting the array; or null to indicate the elements' natural order
    
    Throws:
    
    ClassCastException - if any two elements are not mutually comparable by the Comparator provided
    
    NullPointerException - if a null element is compared with natural ordering (only possible when c is null)
  - sort
```
public static void sort(Object[] a,
                        int fromIndex,
                        int toIndex)
```
    Sort an array of Objects according to their natural ordering. The sort is guaranteed to be stable, that is, equal elements will not be reordered. The sort algorithm is a mergesort with the merge omitted if the last element of one half comes before the first element of the other half. This algorithm gives guaranteed O(n*log(n)) time, at the expense of making a copy of the array.
    
    Parameters:
    
    a - the array to be sorted
    
    fromIndex - the index of the first element to be sorted
    
    toIndex - the index of the last element to be sorted plus one
    
    Throws:
    
    ClassCastException - if any two elements are not mutually comparable
    
    NullPointerException - if an element is null (since null.compareTo cannot work)
    
    ArrayIndexOutOfBoundsException - if fromIndex and toIndex are not in range.
    
    IllegalArgumentException - if fromIndex > toIndex
  - sort
```
public static void sort(Object[] a,
                        int fromIndex,
                        int toIndex,
                        Comparator c)
```
    Sort an array of Objects according to a Comparator. The sort is guaranteed to be stable, that is, equal elements will not be reordered. The sort algorithm is a mergesort with the merge omitted if the last element of one half comes before the first element of the other half. This algorithm gives guaranteed O(n*log(n)) time, at the expense of making a copy of the array.
    
    Parameters:
    
    a - the array to be sorted
    
    fromIndex - the index of the first element to be sorted
    
    toIndex - the index of the last element to be sorted plus one
    
    c - a Comparator to use in sorting the array; or null to indicate the elements' natural order
    
    Throws:
    
    ClassCastException - if any two elements are not mutually comparable by the Comparator provided
    
    ArrayIndexOutOfBoundsException - if fromIndex and toIndex are not in range.
    
    IllegalArgumentException - if fromIndex > toIndex
    
    NullPointerException - if a null element is compared with natural ordering (only possible when c is null)
  - asList
```
public static List asList(Object[] a)
```
    Returns a list "view" of the specified array. This method is intended to make it easy to use the Collections API with existing array-based APIs and programs. Changes in the list or the array show up in both places. The list does not support element addition or removal, but does permit value modification. The returned list implements both Serializable and RandomAccess.
    
    Parameters:
    
    a - the array to return a view of
    
    Returns:
    
    a fixed-size list, changes to which "write through" to the array
    
    See Also:
    
    Serializable, RandomAccess, Arrays.ArrayList

Class Arrays

Method Summary

Methods inherited from class java.lang.Object

Method Detail

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

equals

equals

equals

equals

equals

equals

equals

equals

equals

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

fill

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

sort

asList