Массивы (Платформа Java SE 8 b92)

java.lang. Объект
- java.util. Массивы

```
public class Arrays
extends Object
```
Этот class содержит различные методы для того, чтобы управлять массивами (такими как сортировка и поиск). Этот class также содержит статическую фабрику, которая позволяет массивам просматриваться как списки.
Методы в этом class весь бросок a NullPointerException, если указанная ссылка массива является нулем, кроме где отмечено.
Документация для методов, содержавшихся в этом class, включает описание кратких сводок реализаций. Такие описания должны быть расценены, как реализация отмечает, а не отделяется спецификации. Конструкторы должны не стесняться заменять другими алгоритмами, пока сама спецификация придерживается к. (Например, алгоритм, используемый sort(Object[]) не должен быть MergeSort, но это действительно должно быть устойчиво.)
Этот class является элементом Платформы Наборов Java.

С тех пор:

1.2

Сводка метода

Все Методы Статические Методы Конкретные Методы
Модификатор и Тип	Метод и Описание
`static <T> List<T>`	`asList(T... a)` Возвращает список фиксированного размера, поддержанный указанным массивом.
`static int`	`binarySearch(byte[] a, byte key)` Ищет указанный массив байтов для указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(byte[] a, int fromIndex, int toIndex, byte key)` Ищет диапазон указанного массива байтов для указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(char[] a, char key)` Ищет указанный массив случайных работ для указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(char[] a, int fromIndex, int toIndex, char key)` Ищет диапазон указанного массива случайных работ для указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(double[] a, double key)` Ищет указанный массив удваивается для указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(double[] a, int fromIndex, int toIndex, double key)` Ищет диапазон указанного массива удваивается для указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(float[] a, float key)` Ищет указанный массив плаваний для указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(float[] a, int fromIndex, int toIndex, float key)` Ищет диапазон указанного массива плаваний для указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(int[] a, int key)` Ищет указанный массив ints для указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(int[] a, int fromIndex, int toIndex, int key)` Ищет диапазон указанного массива ints для указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(long[] a, int fromIndex, int toIndex, long key)` Ищет диапазон указанного массива жаждет указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(long[] a, long key)` Ищет указанный массив жаждет указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(Object[] a, int fromIndex, int toIndex, Object key)` Ищет диапазон указанного массива для указанного объекта, используя алгоритм двоичного поиска.
`static int`	`binarySearch(Object[] a, Object key)` Ищет указанный массив указанный объект, используя алгоритм двоичного поиска.
`static int`	`binarySearch(short[] a, int fromIndex, int toIndex, short key)` Ищет диапазон указанного массива шорт для указанного значения, используя алгоритм двоичного поиска.
`static int`	`binarySearch(short[] a, short key)` Ищет указанный массив шорт для указанного значения, используя алгоритм двоичного поиска.
`static <T> int`	`binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)` Ищет диапазон указанного массива для указанного объекта, используя алгоритм двоичного поиска.
`static <T> int`	`binarySearch(T[] a, T key, Comparator<? super T> c)` Ищет указанный массив указанный объект, используя алгоритм двоичного поиска.
`static boolean[]`	`copyOf(boolean[] original, int newLength)` Копирует указанный массив, усекая или дополняя `false` (в случае необходимости), таким образом, у копии есть указанная длина.
`static byte[]`	`copyOf(byte[] original, int newLength)` Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина.
`static char[]`	`copyOf(char[] original, int newLength)` Копирует указанный массив, усекая или дополняя нулевыми символами (в случае необходимости), таким образом, у копии есть указанная длина.
`static double[]`	`copyOf(double[] original, int newLength)` Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина.
`static float[]`	`copyOf(float[] original, int newLength)` Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина.
`static int[]`	`copyOf(int[] original, int newLength)` Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина.
`static long[]`	`copyOf(long[] original, int newLength)` Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина.
`static short[]`	`copyOf(short[] original, int newLength)` Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина.
`static <T> T[]`	`copyOf(T[] original, int newLength)` Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина.
`static <T,U> T[]`	`copyOf(U[] original, int newLength, Class<? extends T[]> newType)` Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина.
`static boolean[]`	`copyOfRange(boolean[] original, int from, int to)` Копирует указанный диапазон указанного массива в новый массив.
`static byte[]`	`copyOfRange(byte[] original, int from, int to)` Копирует указанный диапазон указанного массива в новый массив.
`static char[]`	`copyOfRange(char[] original, int from, int to)` Копирует указанный диапазон указанного массива в новый массив.
`static double[]`	`copyOfRange(double[] original, int from, int to)` Копирует указанный диапазон указанного массива в новый массив.
`static float[]`	`copyOfRange(float[] original, int from, int to)` Копирует указанный диапазон указанного массива в новый массив.
`static int[]`	`copyOfRange(int[] original, int from, int to)` Копирует указанный диапазон указанного массива в новый массив.
`static long[]`	`copyOfRange(long[] original, int from, int to)` Копирует указанный диапазон указанного массива в новый массив.
`static short[]`	`copyOfRange(short[] original, int from, int to)` Копирует указанный диапазон указанного массива в новый массив.
`static <T> T[]`	`copyOfRange(T[] original, int from, int to)` Копирует указанный диапазон указанного массива в новый массив.
`static <T,U> T[]`	`copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)` Копирует указанный диапазон указанного массива в новый массив.
`static boolean`	`deepEquals(Object[] a1, Object[] a2)` `true` возвратов, если два указанных массива очень равны друг другу.
`static int`	`deepHashCode(Object[] a)` Возвращает хэш-код, основанный на "глубоком содержании" указанного массива.
`static String`	`deepToString(Object[] a)` Возвращает строковое представление "глубокого содержания" указанного массива.
`static boolean`	`equals(boolean[] a, boolean[] a2)` `true` возвратов, если два указанных массива булевских переменных равны друг другу.
`static boolean`	`equals(byte[] a, byte[] a2)` `true` возвратов, если два указанных массива байтов равны друг другу.
`static boolean`	`equals(char[] a, char[] a2)` `true` возвратов, если два указанных массива случайных работ равны друг другу.
`static boolean`	`equals(double[] a, double[] a2)` Возвраты `true`, если два указанных массива удваивается, равны друг другу.
`static boolean`	`equals(float[] a, float[] a2)` `true` возвратов, если два указанных массива плаваний равны друг другу.
`static boolean`	`equals(int[] a, int[] a2)` `true` возвратов, если два указанных массива ints равны друг другу.
`static boolean`	`equals(long[] a, long[] a2)` `true` возвратов, если два указанных массива longs равны друг другу.
`static boolean`	`equals(Object[] a, Object[] a2)` `true` возвратов, если два указанных массива Объектов равны друг другу.
`static boolean`	`equals(short[] a, short[] a2)` `true` возвратов, если два указанных массива шорт равны друг другу.
`static void`	`fill(boolean[] a, boolean val)` Присваивает указанное булево значение каждому элементу указанного массива булевских переменных.
`static void`	`fill(boolean[] a, int fromIndex, int toIndex, boolean val)` Присваивает указанное булево значение каждому элементу указанного диапазона указанного массива булевских переменных.
`static void`	`fill(byte[] a, byte val)` Присваивает указанное значение байта каждому элементу указанного массива байтов.
`static void`	`fill(byte[] a, int fromIndex, int toIndex, byte val)` Присваивает указанное значение байта каждому элементу указанного диапазона указанного массива байтов.
`static void`	`fill(char[] a, char val)` Присваивает указанное значение случайной работы каждому элементу указанного массива случайных работ.
`static void`	`fill(char[] a, int fromIndex, int toIndex, char val)` Присваивает указанное значение случайной работы каждому элементу указанного диапазона указанного массива случайных работ.
`static void`	`fill(double[] a, double val)` Присваивается указанное двойное значение к каждому элементу указанного массива удваивается.
`static void`	`fill(double[] a, int fromIndex, int toIndex, double val)` Присваивается указанное двойное значение к каждому элементу указанного диапазона указанного массива удваивается.
`static void`	`fill(float[] a, float val)` Присваивает указанное значение плавающее каждому элементу указанного массива плаваний.
`static void`	`fill(float[] a, int fromIndex, int toIndex, float val)` Присваивает указанное значение плавающее каждому элементу указанного диапазона указанного массива плаваний.
`static void`	`fill(int[] a, int val)` Присваивает указанное международное значение каждому элементу указанного массива ints.
`static void`	`fill(int[] a, int fromIndex, int toIndex, int val)` Присваивает указанное международное значение каждому элементу указанного диапазона указанного массива ints.
`static void`	`fill(long[] a, int fromIndex, int toIndex, long val)` Присваивает указанное длинное значение каждому элементу указанного диапазона указанного массива longs.
`static void`	`fill(long[] a, long val)` Присваивает указанное длинное значение каждому элементу указанного массива longs.
`static void`	`fill(Object[] a, int fromIndex, int toIndex, Object val)` Присваивает указанную Ссылку на объект на каждый элемент указанного диапазона указанного массива Объектов.
`static void`	`fill(Object[] a, Object val)` Присваивает указанную Ссылку на объект на каждый элемент указанного массива Объектов.
`static void`	`fill(short[] a, int fromIndex, int toIndex, short val)` Присваивает указанное короткое значение каждому элементу указанного диапазона указанного массива шорт.
`static void`	`fill(short[] a, short val)` Присваивает указанное короткое значение каждому элементу указанного массива шорт.
`static int`	`hashCode(boolean[] a)` Возвращает хэш-код, основанный на содержании указанного массива.
`static int`	`hashCode(byte[] a)` Возвращает хэш-код, основанный на содержании указанного массива.
`static int`	`hashCode(char[] a)` Возвращает хэш-код, основанный на содержании указанного массива.
`static int`	`hashCode(double[] a)` Возвращает хэш-код, основанный на содержании указанного массива.
`static int`	`hashCode(float[] a)` Возвращает хэш-код, основанный на содержании указанного массива.
`static int`	`hashCode(int[] a)` Возвращает хэш-код, основанный на содержании указанного массива.
`static int`	`hashCode(long[] a)` Возвращает хэш-код, основанный на содержании указанного массива.
`static int`	`hashCode(Object[] a)` Возвращает хэш-код, основанный на содержании указанного массива.
`static int`	`hashCode(short[] a)` Возвращает хэш-код, основанный на содержании указанного массива.
`static void`	`parallelSetAll(double[] array, IntToDoubleFunction generator)` Установите все элементы указанного массива, параллельно, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
`static void`	`parallelSetAll(int[] array, IntUnaryOperator generator)` Установите все элементы указанного массива, параллельно, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
`static void`	`parallelSetAll(long[] array, IntToLongFunction generator)` Установите все элементы указанного массива, параллельно, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
`static <T> void`	`parallelSetAll(T[] array, IntFunction<? extends T> generator)` Установите все элементы указанного массива, параллельно, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
`static void`	`parallelSort(byte[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`parallelSort(byte[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static void`	`parallelSort(char[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`parallelSort(char[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static void`	`parallelSort(double[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`parallelSort(double[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static void`	`parallelSort(float[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`parallelSort(float[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static void`	`parallelSort(int[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`parallelSort(int[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static void`	`parallelSort(long[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`parallelSort(long[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static void`	`parallelSort(short[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`parallelSort(short[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static <T extends Comparable<? super T>> void`	`parallelSort(T[] a)` Сортирует указанный массив объектов в порядок по возрастанию, согласно естественному упорядочиванию его элементов.
`static <T> void`	`parallelSort(T[] a, Comparator<? super T> c)` Сортирует указанный массив объектов согласно порядку, вызванному указанным компаратором.
`static <T extends Comparable<? super T>> void`	`parallelSort(T[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон указанного массива объектов в порядок по возрастанию, согласно естественному упорядочиванию его элементов.
`static <T> void`	`parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)` Сортирует указанный диапазон указанного массива объектов согласно порядку, вызванному указанным компаратором.
`static void`	`setAll(double[] array, IntToDoubleFunction generator)` Установите все элементы указанного массива, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
`static void`	`setAll(int[] array, IntUnaryOperator generator)` Установите все элементы указанного массива, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
`static void`	`setAll(long[] array, IntToLongFunction generator)` Установите все элементы указанного массива, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
`static <T> void`	`setAll(T[] array, IntFunction<? extends T> generator)` Установите все элементы указанного массива, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
`static void`	`sort(byte[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`sort(byte[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static void`	`sort(char[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`sort(char[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static void`	`sort(double[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`sort(double[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static void`	`sort(float[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`sort(float[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static void`	`sort(int[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`sort(int[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static void`	`sort(long[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`sort(long[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static void`	`sort(Object[] a)` Сортирует указанный массив объектов в порядок по возрастанию, согласно естественному упорядочиванию его элементов.
`static void`	`sort(Object[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон указанного массива объектов в порядок по возрастанию, согласно естественному упорядочиванию его элементов.
`static void`	`sort(short[] a)` Сортирует указанный массив в возрастающий числовой порядок.
`static void`	`sort(short[] a, int fromIndex, int toIndex)` Сортирует указанный диапазон массива в порядок по возрастанию.
`static <T> void`	`sort(T[] a, Comparator<? super T> c)` Сортирует указанный массив объектов согласно порядку, вызванному указанным компаратором.
`static <T> void`	`sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)` Сортирует указанный диапазон указанного массива объектов согласно порядку, вызванному указанным компаратором.
`static Spliterator.OfDouble`	`spliterator(double[] array)` Возвраты a `Spliterator.OfDouble` покрытие всего указанного массива.
`static Spliterator.OfDouble`	`spliterator(double[] array, int startInclusive, int endExclusive)` Возвраты a `Spliterator.OfDouble` покрытие указанного диапазона указанного массива.
`static Spliterator.OfInt`	`spliterator(int[] array)` Возвраты a `Spliterator.OfInt` покрытие всего указанного массива.
`static Spliterator.OfInt`	`spliterator(int[] array, int startInclusive, int endExclusive)` Возвраты a `Spliterator.OfInt` покрытие указанного диапазона указанного массива.
`static Spliterator.OfLong`	`spliterator(long[] array)` Возвраты a `Spliterator.OfLong` покрытие всего указанного массива.
`static Spliterator.OfLong`	`spliterator(long[] array, int startInclusive, int endExclusive)` Возвраты a `Spliterator.OfLong` покрытие указанного диапазона указанного массива.
`static <T> Spliterator<T>`	`spliterator(T[] array)` Возвраты a `Spliterator` покрытие всего указанного массива.
`static <T> Spliterator<T>`	`spliterator(T[] array, int startInclusive, int endExclusive)` Возвраты a `Spliterator` покрытие указанного диапазона указанного массива.
`static DoubleStream`	`stream(double[] array)` Возвращает последовательное `DoubleStream` с указанным массивом как его источник.
`static DoubleStream`	`stream(double[] array, int startInclusive, int endExclusive)` Возвращает последовательное `DoubleStream` с указанным диапазоном указанного массива как его источник.
`static IntStream`	`stream(int[] array)` Возвращает последовательное `IntStream` с указанным массивом как его источник.
`static IntStream`	`stream(int[] array, int startInclusive, int endExclusive)` Возвращает последовательное `IntStream` с указанным диапазоном указанного массива как его источник.
`static LongStream`	`stream(long[] array)` Возвращает последовательное `LongStream` с указанным массивом как его источник.
`static LongStream`	`stream(long[] array, int startInclusive, int endExclusive)` Возвращает последовательное `LongStream` с указанным диапазоном указанного массива как его источник.
`static <T> Stream<T>`	`stream(T[] array)` Возвращает последовательное `Stream` с указанным массивом как его источник.
`static <T> Stream<T>`	`stream(T[] array, int startInclusive, int endExclusive)` Возвращает последовательное `Stream` с указанным диапазоном указанного массива как его источник.
`static String`	`toString(boolean[] a)` Возвращает строковое представление содержания указанного массива.
`static String`	`toString(byte[] a)` Возвращает строковое представление содержания указанного массива.
`static String`	`toString(char[] a)` Возвращает строковое представление содержания указанного массива.
`static String`	`toString(double[] a)` Возвращает строковое представление содержания указанного массива.
`static String`	`toString(float[] a)` Возвращает строковое представление содержания указанного массива.
`static String`	`toString(int[] a)` Возвращает строковое представление содержания указанного массива.
`static String`	`toString(long[] a)` Возвращает строковое представление содержания указанного массива.
`static String`	`toString(Object[] a)` Возвращает строковое представление содержания указанного массива.
`static String`	`toString(short[] a)` Возвращает строковое представление содержания указанного массива.

Методы, наследованные от class java.lang. Объект
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Деталь метода
  - вид
```
public static void sort(int[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
  - вид
```
public static void sort(int[] a,
                        int fromIndex,
                        int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - вид
```
public static void sort(long[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
  - вид
```
public static void sort(long[] a,
                        int fromIndex,
                        int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - вид
```
public static void sort(short[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
  - вид
```
public static void sort(short[] a,
                        int fromIndex,
                        int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - вид
```
public static void sort(char[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
  - вид
```
public static void sort(char[] a,
                        int fromIndex,
                        int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - вид
```
public static void sort(byte[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
  - вид
```
public static void sort(byte[] a,
                        int fromIndex,
                        int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - вид
```
public static void sort(float[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    < отношение не обеспечивает полный порядок на все значения плавающие: -0.0f == 0.0f true и a Float.NaN значение не сравнивает ни меньше чем, больше чем, ни равный любому значению, даже непосредственно. Этот метод использует полный порядок, наложенный методом Float.compareTo(java.lang.Float): -0.0f обрабатывается как меньше чем значение 0.0f и Float.NaN считается больше чем любое другое значение и все Float.NaN значения считают равными.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
  - вид
```
public static void sort(float[] a,
                        int fromIndex,
                        int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    < отношение не обеспечивает полный порядок на все значения плавающие: -0.0f == 0.0f true и a Float.NaN значение не сравнивает ни меньше чем, больше чем, ни равный любому значению, даже непосредственно. Этот метод использует полный порядок, наложенный методом Float.compareTo(java.lang.Float): -0.0f обрабатывается как меньше чем значение 0.0f и Float.NaN считается больше чем любое другое значение и все Float.NaN значения считают равными.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - вид
```
public static void sort(double[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    < отношение не обеспечивает полный порядок на все двойные значения: -0.0d == 0.0d true и a Double.NaN значение не сравнивает ни меньше чем, больше чем, ни равный любому значению, даже непосредственно. Этот метод использует полный порядок, наложенный методом Double.compareTo(java.lang.Double): -0.0d обрабатывается как меньше чем значение 0.0d и Double.NaN считается больше чем любое другое значение и все Double.NaN значения считают равными.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
  - вид
```
public static void sort(double[] a,
                        int fromIndex,
                        int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    < отношение не обеспечивает полный порядок на все двойные значения: -0.0d == 0.0d true и a Double.NaN значение не сравнивает ни меньше чем, больше чем, ни равный любому значению, даже непосредственно. Этот метод использует полный порядок, наложенный методом Double.compareTo(java.lang.Double): -0.0d обрабатывается как меньше чем значение 0.0d и Double.NaN считается больше чем любое другое значение и все Double.NaN значения считают равными.
    Примечание реализации: алгоритм сортировки является Двойным центром Quicksort Владимиром Ярославскием, Бентли Джона, и Джошуа Блохом. Этот алгоритм предлагает O (n журнал (n)) производительность на многих наборах данных, которые заставляют другой quicksorts ухудшаться к квадратной производительности, и обычно быстрее чем традиционные реализации Quicksort (с одним центром).
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - вид
```
public static void sort(Object[] a)
```
    Сортирует указанный массив объектов в порядок по возрастанию, согласно естественному упорядочиванию его элементов. Все элементы в массиве должны реализовать Comparable интерфейс. Кроме того все элементы в массиве должны быть взаимно сопоставимыми (то есть, e1.compareTo(e2) не должен бросить a ClassCastException для любых элементов e1 и e2 в массиве).
    Этот вид, как гарантируют, будет устойчив: равные элементы не будут переупорядочены в результате вида.
    Примечание реализации: Эта реализация является устойчивой, адаптивной, итеративной сортировкой с объединением, которая требует гораздо меньше чем n lg (n) сравнения, когда входной массив частично сортируется, предлагая производительность традиционной сортировки с объединением, когда входному массиву в произвольном порядке упорядочивают. Если входной массив почти сортируется, реализация требует приблизительно n сравнений. Временные требования хранения изменяются от маленькой константы для почти сортированных входных массивов к n/2 ссылкам на объект для в произвольном порядке упорядоченных входных массивов.
    Реализация пользуется равным преимуществом порядка по возрастанию и порядка по убыванию в его входном массиве, и может использовать в своих интересах порядок по возрастанию и порядка по убыванию в различных частях тот же самый входной массив. Это является подходящим к слиянию двух или больше сортированных массивов: просто свяжите массивы и сортируйте получающийся массив.
    Реализация была адаптирована от вида списка Тима Петерса к Python (TimSort). Это использует techiques от "Оптимистической Сортировки Питера Макилроя и информации Теоретическая Сложность", в Продолжениях Четвертого Ежегодного Симпозиума ACM-СИАМА по Дискретным Алгоритмам, стр 467-474, январь 1993.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    Броски:
    
    ClassCastException - если массив содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа)
    
    IllegalArgumentException - (дополнительный), если естественное упорядочивание элементов массива, как находят, нарушает Comparable контракт
  - вид
```
public static void sort(Object[] a,
                        int fromIndex,
                        int toIndex)
```
    Сортирует указанный диапазон указанного массива объектов в порядок по возрастанию, согласно естественному упорядочиванию его элементов. Диапазон, который будет сортирован, расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, который будет сортирован, пуст.) Все элементы в этом диапазоне должны реализовать Comparable интерфейс. Кроме того все элементы в этом диапазоне должны быть взаимно сопоставимыми (то есть, e1.compareTo(e2) не должен бросить a ClassCastException для любых элементов e1 и e2 в массиве).
    Этот вид, как гарантируют, будет устойчив: равные элементы не будут переупорядочены в результате вида.
    Примечание реализации: Эта реализация является устойчивой, адаптивной, итеративной сортировкой с объединением, которая требует гораздо меньше чем n lg (n) сравнения, когда входной массив частично сортируется, предлагая производительность традиционной сортировки с объединением, когда входному массиву в произвольном порядке упорядочивают. Если входной массив почти сортируется, реализация требует приблизительно n сравнений. Временные требования хранения изменяются от маленькой константы для почти сортированных входных массивов к n/2 ссылкам на объект для в произвольном порядке упорядоченных входных массивов.
    Реализация пользуется равным преимуществом порядка по возрастанию и порядка по убыванию в его входном массиве, и может использовать в своих интересах порядок по возрастанию и порядка по убыванию в различных частях тот же самый входной массив. Это является подходящим к слиянию двух или больше сортированных массивов: просто свяжите массивы и сортируйте получающийся массив.
    Реализация была адаптирована от вида списка Тима Петерса к Python (TimSort). Это использует techiques от "Оптимистической Сортировки Питера Макилроя и информации Теоретическая Сложность", в Продолжениях Четвертого Ежегодного Симпозиума ACM-СИАМА по Дискретным Алгоритмам, стр 467-474, январь 1993.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть сортированным
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex или (дополнительный), если естественное упорядочивание элементов массива, как находят, нарушает Comparable контракт
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
    
    ClassCastException - если массив содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа).
  - вид
```
public static <T> void sort(T[] a,
                            Comparator<? super T> c)
```
    Сортирует указанный массив объектов согласно порядку, вызванному указанным компаратором. Все элементы в массиве должны быть взаимно сопоставимыми указанным компаратором (то есть, c.compare(e1, e2) не должен бросить a ClassCastException для любых элементов e1 и e2 в массиве).
    Этот вид, как гарантируют, будет устойчив: равные элементы не будут переупорядочены в результате вида.
    Примечание реализации: Эта реализация является устойчивой, адаптивной, итеративной сортировкой с объединением, которая требует гораздо меньше чем n lg (n) сравнения, когда входной массив частично сортируется, предлагая производительность традиционной сортировки с объединением, когда входному массиву в произвольном порядке упорядочивают. Если входной массив почти сортируется, реализация требует приблизительно n сравнений. Временные требования хранения изменяются от маленькой константы для почти сортированных входных массивов к n/2 ссылкам на объект для в произвольном порядке упорядоченных входных массивов.
    Реализация пользуется равным преимуществом порядка по возрастанию и порядка по убыванию в его входном массиве, и может использовать в своих интересах порядок по возрастанию и порядка по убыванию в различных частях тот же самый входной массив. Это является подходящим к слиянию двух или больше сортированных массивов: просто свяжите массивы и сортируйте получающийся массив.
    Реализация была адаптирована от вида списка Тима Петерса к Python (TimSort). Это использует techiques от "Оптимистической Сортировки Питера Макилроя и информации Теоретическая Сложность", в Продолжениях Четвертого Ежегодного Симпозиума ACM-СИАМА по Дискретным Алгоритмам, стр 467-474, январь 1993.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    c - компаратор, чтобы определить порядок массива. A null значение указывает, что естественное упорядочивание элементов должно использоваться.
    
    Броски:
    
    ClassCastException - если массив содержит элементы, которые не являются взаимно сопоставимым использованием указанного компаратора
    
    IllegalArgumentException - (дополнительный), если компаратор, как находят, нарушает Comparator контракт
  - вид
```
public static <T> void sort(T[] a,
                            int fromIndex,
                            int toIndex,
                            Comparator<? super T> c)
```
    Сортирует указанный диапазон указанного массива объектов согласно порядку, вызванному указанным компаратором. Диапазон, который будет сортирован, расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, который будет сортирован, пуст.) Все элементы в диапазоне должны быть взаимно сопоставимыми указанным компаратором (то есть, c.compare(e1, e2) не должен бросить a ClassCastException для любых элементов e1 и e2 в диапазоне).
    Этот вид, как гарантируют, будет устойчив: равные элементы не будут переупорядочены в результате вида.
    Примечание реализации: Эта реализация является устойчивой, адаптивной, итеративной сортировкой с объединением, которая требует гораздо меньше чем n lg (n) сравнения, когда входной массив частично сортируется, предлагая производительность традиционной сортировки с объединением, когда входному массиву в произвольном порядке упорядочивают. Если входной массив почти сортируется, реализация требует приблизительно n сравнений. Временные требования хранения изменяются от маленькой константы для почти сортированных входных массивов к n/2 ссылкам на объект для в произвольном порядке упорядоченных входных массивов.
    Реализация пользуется равным преимуществом порядка по возрастанию и порядка по убыванию в его входном массиве, и может использовать в своих интересах порядок по возрастанию и порядка по убыванию в различных частях тот же самый входной массив. Это является подходящим к слиянию двух или больше сортированных массивов: просто свяжите массивы и сортируйте получающийся массив.
    Реализация была адаптирована от вида списка Тима Петерса к Python (TimSort). Это использует techiques от "Оптимистической Сортировки Питера Макилроя и информации Теоретическая Сложность", в Продолжениях Четвертого Ежегодного Симпозиума ACM-СИАМА по Дискретным Алгоритмам, стр 467-474, январь 1993.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть сортированным
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть сортированным
    
    c - компаратор, чтобы определить порядок массива. A null значение указывает, что естественное упорядочивание элементов должно использоваться.
    
    Броски:
    
    ClassCastException - если массив содержит элементы, которые не являются взаимно сопоставимым использованием указанного компаратора.
    
    IllegalArgumentException - если fromIndex > toIndex или (дополнительный), если компаратор, как находят, нарушает Comparator контракт
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - parallelSort
```
public static void parallelSort(byte[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(byte[] a,
                                int fromIndex,
                                int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(char[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(char[] a,
                                int fromIndex,
                                int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(short[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(short[] a,
                                int fromIndex,
                                int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(int[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(int[] a,
                                int fromIndex,
                                int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(long[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(long[] a,
                                int fromIndex,
                                int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(float[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    < отношение не обеспечивает полный порядок на все значения плавающие: -0.0f == 0.0f true и a Float.NaN значение не сравнивает ни меньше чем, больше чем, ни равный любому значению, даже непосредственно. Этот метод использует полный порядок, наложенный методом Float.compareTo(java.lang.Float): -0.0f обрабатывается как меньше чем значение 0.0f и Float.NaN считается больше чем любое другое значение и все Float.NaN значения считают равными.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(float[] a,
                                int fromIndex,
                                int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    < отношение не обеспечивает полный порядок на все значения плавающие: -0.0f == 0.0f true и a Float.NaN значение не сравнивает ни меньше чем, больше чем, ни равный любому значению, даже непосредственно. Этот метод использует полный порядок, наложенный методом Float.compareTo(java.lang.Float): -0.0f обрабатывается как меньше чем значение 0.0f и Float.NaN считается больше чем любое другое значение и все Float.NaN значения считают равными.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(double[] a)
```
    Сортирует указанный массив в возрастающий числовой порядок.
    < отношение не обеспечивает полный порядок на все двойные значения: -0.0d == 0.0d true и a Double.NaN значение не сравнивает ни меньше чем, больше чем, ни равный любому значению, даже непосредственно. Этот метод использует полный порядок, наложенный методом Double.compareTo(java.lang.Double): -0.0d обрабатывается как меньше чем значение 0.0d и Double.NaN считается больше чем любое другое значение и все Double.NaN значения считают равными.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static void parallelSort(double[] a,
                                int fromIndex,
                                int toIndex)
```
    Сортирует указанный диапазон массива в порядок по возрастанию. Диапазон, который будет сортирован, расширяется от индексирования fromIndex, включительно, к индексированию toIndex, монопольный. Если fromIndex == toIndex, диапазон, который будет сортирован, пуст.
    < отношение не обеспечивает полный порядок на все двойные значения: -0.0d == 0.0d true и a Double.NaN значение не сравнивает ни меньше чем, больше чем, ни равный любому значению, даже непосредственно. Этот метод использует полный порядок, наложенный методом Double.compareTo(java.lang.Double): -0.0d обрабатывается как меньше чем значение 0.0d и Double.NaN считается больше чем любое другое значение и все Double.NaN значения считают равными.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента, включительно, чтобы быть сортированным
    
    toIndex - индексирование последнего элемента, монопольного, чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static <T extends Comparable<? super T>> void parallelSort(T[] a)
```
    Сортирует указанный массив объектов в порядок по возрастанию, согласно естественному упорядочиванию его элементов. Все элементы в массиве должны реализовать Comparable интерфейс. Кроме того все элементы в массиве должны быть взаимно сопоставимыми (то есть, e1.compareTo(e2) не должен бросить a ClassCastException для любых элементов e1 и e2 в массиве).
    Этот вид, как гарантируют, не будет устойчив: равные элементы могут быть переупорядочены в результате вида.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    Броски:
    
    ClassCastException - если массив содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа)
    
    IllegalArgumentException - (дополнительный), если естественное упорядочивание элементов массива, как находят, нарушает Comparable контракт
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static <T extends Comparable<? super T>> void parallelSort(T[] a,
                                                                  int fromIndex,
                                                                  int toIndex)
```
    Сортирует указанный диапазон указанного массива объектов в порядок по возрастанию, согласно естественному упорядочиванию его элементов. Диапазон, который будет сортирован, расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, который будет сортирован, пуст.) Все элементы в этом диапазоне должны реализовать Comparable интерфейс. Кроме того все элементы в этом диапазоне должны быть взаимно сопоставимыми (то есть, e1.compareTo(e2) не должен бросить a ClassCastException для любых элементов e1 и e2 в массиве).
    Этот вид, как гарантируют, не будет устойчив: равные элементы могут быть переупорядочены в результате вида.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть сортированным
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть сортированным
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex или (дополнительный), если естественное упорядочивание элементов массива, как находят, нарушает Comparable контракт
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
    
    ClassCastException - если массив содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа).
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static <T> void parallelSort(T[] a,
                                    Comparator<? super T> c)
```
    Сортирует указанный массив объектов согласно порядку, вызванному указанным компаратором. Все элементы в массиве должны быть взаимно сопоставимыми указанным компаратором (то есть, c.compare(e1, e2) не должен бросить a ClassCastException для любых элементов e1 и e2 в массиве).
    Этот вид, как гарантируют, не будет устойчив: равные элементы могут быть переупорядочены в результате вида.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    c - компаратор, чтобы определить порядок массива. A null значение указывает, что естественное упорядочивание элементов должно использоваться.
    
    Броски:
    
    ClassCastException - если массив содержит элементы, которые не являются взаимно сопоставимым использованием указанного компаратора
    
    IllegalArgumentException - (дополнительный), если компаратор, как находят, нарушает Comparator контракт
    
    С тех пор:
    
    1.8
  - parallelSort
```
public static <T> void parallelSort(T[] a,
                                    int fromIndex,
                                    int toIndex,
                                    Comparator<? super T> c)
```
    Сортирует указанный диапазон указанного массива объектов согласно порядку, вызванному указанным компаратором. Диапазон, который будет сортирован, расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, который будет сортирован, пуст.) Все элементы в диапазоне должны быть взаимно сопоставимыми указанным компаратором (то есть, c.compare(e1, e2) не должен бросить a ClassCastException для любых элементов e1 и e2 в диапазоне).
    Этот вид, как гарантируют, не будет устойчив: равные элементы могут быть переупорядочены в результате вида.
    Примечание реализации: алгоритм сортировки является параллельным слиянием вида, которое повреждает массив в подмассивы, которые самостоятельно сортируются и затем объединяются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется, используя соответствующее Arrays.sort метод. Алгоритм требует рабочей области, равной размеру исходного массива. ForkJoin common pool используется, чтобы выполнить любые параллельные задачи.
    
    Параметры:
    
    a - массив, который будет сортирован
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть сортированным
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть сортированным
    
    c - компаратор, чтобы определить порядок массива. A null значение указывает, что естественное упорядочивание элементов должно использоваться.
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex или (дополнительный), если естественное упорядочивание элементов массива, как находят, нарушает Comparable контракт
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
    
    ClassCastException - если массив содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа).
    
    С тех пор:
    
    1.8
  - binarySearch
```
public static int binarySearch(long[] a,
                               long key)
```
    Ищет указанный массив жаждет указанного значения, используя алгоритм двоичного поиска. Массив должен быть сортирован (как sort(long[]) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если массив содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента, больше чем ключ, или a.length, если все элементы в массиве являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
  - binarySearch
```
public static int binarySearch(long[] a,
                               int fromIndex,
                               int toIndex,
                               long key)
```
    Ищет диапазон указанного массива жаждет указанного значения, используя алгоритм двоичного поиска. Диапазон должен быть сортирован (как sort(long[], int, int) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если диапазон содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    fromIndex - индексирование первого элемента (включительно), чтобы искаться
    
    toIndex - индексирование последнего элемента (монопольного), чтобы искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве в пределах указанного диапазона; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента в диапазоне, больше чем ключ, или toIndex, если все элементы в диапазоне являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 or toIndex > a.length
    
    С тех пор:
    
    1.6
  - binarySearch
```
public static int binarySearch(int[] a,
                               int key)
```
    Ищет указанный массив ints для указанного значения, используя алгоритм двоичного поиска. Массив должен быть сортирован (как sort(int[]) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если массив содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента, больше чем ключ, или a.length, если все элементы в массиве являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
  - binarySearch
```
public static int binarySearch(int[] a,
                               int fromIndex,
                               int toIndex,
                               int key)
```
    Ищет диапазон указанного массива ints для указанного значения, используя алгоритм двоичного поиска. Диапазон должен быть сортирован (как sort(int[], int, int) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если диапазон содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    fromIndex - индексирование первого элемента (включительно), чтобы искаться
    
    toIndex - индексирование последнего элемента (монопольного), чтобы искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве в пределах указанного диапазона; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента в диапазоне, больше чем ключ, или toIndex, если все элементы в диапазоне являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 or toIndex > a.length
    
    С тех пор:
    
    1.6
  - binarySearch
```
public static int binarySearch(short[] a,
                               short key)
```
    Ищет указанный массив шорт для указанного значения, используя алгоритм двоичного поиска. Массив должен быть сортирован (как sort(short[]) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если массив содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента, больше чем ключ, или a.length, если все элементы в массиве являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
  - binarySearch
```
public static int binarySearch(short[] a,
                               int fromIndex,
                               int toIndex,
                               short key)
```
    Ищет диапазон указанного массива шорт для указанного значения, используя алгоритм двоичного поиска. Диапазон должен быть сортирован (как sort(short[], int, int) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если диапазон содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    fromIndex - индексирование первого элемента (включительно), чтобы искаться
    
    toIndex - индексирование последнего элемента (монопольного), чтобы искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве в пределах указанного диапазона; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента в диапазоне, больше чем ключ, или toIndex, если все элементы в диапазоне являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 or toIndex > a.length
    
    С тех пор:
    
    1.6
  - binarySearch
```
public static int binarySearch(char[] a,
                               char key)
```
    Ищет указанный массив случайных работ для указанного значения, используя алгоритм двоичного поиска. Массив должен быть сортирован (как sort(char[]) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если массив содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента, больше чем ключ, или a.length, если все элементы в массиве являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
  - binarySearch
```
public static int binarySearch(char[] a,
                               int fromIndex,
                               int toIndex,
                               char key)
```
    Ищет диапазон указанного массива случайных работ для указанного значения, используя алгоритм двоичного поиска. Диапазон должен быть сортирован (как sort(char[], int, int) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если диапазон содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    fromIndex - индексирование первого элемента (включительно), чтобы искаться
    
    toIndex - индексирование последнего элемента (монопольного), чтобы искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве в пределах указанного диапазона; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента в диапазоне, больше чем ключ, или toIndex, если все элементы в диапазоне являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 or toIndex > a.length
    
    С тех пор:
    
    1.6
  - binarySearch
```
public static int binarySearch(byte[] a,
                               byte key)
```
    Ищет указанный массив байтов для указанного значения, используя алгоритм двоичного поиска. Массив должен быть сортирован (как sort(byte[]) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если массив содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента, больше чем ключ, или a.length, если все элементы в массиве являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
  - binarySearch
```
public static int binarySearch(byte[] a,
                               int fromIndex,
                               int toIndex,
                               byte key)
```
    Ищет диапазон указанного массива байтов для указанного значения, используя алгоритм двоичного поиска. Диапазон должен быть сортирован (как sort(byte[], int, int) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если диапазон содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    fromIndex - индексирование первого элемента (включительно), чтобы искаться
    
    toIndex - индексирование последнего элемента (монопольного), чтобы искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве в пределах указанного диапазона; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента в диапазоне, больше чем ключ, или toIndex, если все элементы в диапазоне являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 or toIndex > a.length
    
    С тех пор:
    
    1.6
  - binarySearch
```
public static int binarySearch(double[] a,
                               double key)
```
    Ищет указанный массив удваивается для указанного значения, используя алгоритм двоичного поиска. Массив должен быть сортирован (как sort(double[]) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если массив содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден. Этот метод полагает, что все значения НЭН эквивалентны и равны.
    
    Параметры:
    
    a - массив, который будет искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента, больше чем ключ, или a.length, если все элементы в массиве являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
  - binarySearch
```
public static int binarySearch(double[] a,
                               int fromIndex,
                               int toIndex,
                               double key)
```
    Ищет диапазон указанного массива удваивается для указанного значения, используя алгоритм двоичного поиска. Диапазон должен быть сортирован (как sort(double[], int, int) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если диапазон содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден. Этот метод полагает, что все значения НЭН эквивалентны и равны.
    
    Параметры:
    
    a - массив, который будет искаться
    
    fromIndex - индексирование первого элемента (включительно), чтобы искаться
    
    toIndex - индексирование последнего элемента (монопольного), чтобы искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве в пределах указанного диапазона; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента в диапазоне, больше чем ключ, или toIndex, если все элементы в диапазоне являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 or toIndex > a.length
    
    С тех пор:
    
    1.6
  - binarySearch
```
public static int binarySearch(float[] a,
                               float key)
```
    Ищет указанный массив плаваний для указанного значения, используя алгоритм двоичного поиска. Массив должен быть сортирован (как sort(float[]) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если массив содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден. Этот метод полагает, что все значения НЭН эквивалентны и равны.
    
    Параметры:
    
    a - массив, который будет искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента, больше чем ключ, или a.length, если все элементы в массиве являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
  - binarySearch
```
public static int binarySearch(float[] a,
                               int fromIndex,
                               int toIndex,
                               float key)
```
    Ищет диапазон указанного массива плаваний для указанного значения, используя алгоритм двоичного поиска. Диапазон должен быть сортирован (как sort(float[], int, int) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если диапазон содержит многократные элементы с указанным значением, нет никакой гарантии, которой будет найден. Этот метод полагает, что все значения НЭН эквивалентны и равны.
    
    Параметры:
    
    a - массив, который будет искаться
    
    fromIndex - индексирование первого элемента (включительно), чтобы искаться
    
    toIndex - индексирование последнего элемента (монопольного), чтобы искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве в пределах указанного диапазона; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента в диапазоне, больше чем ключ, или toIndex, если все элементы в диапазоне являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 or toIndex > a.length
    
    С тех пор:
    
    1.6
  - binarySearch
```
public static int binarySearch(Object[] a,
                               Object key)
```
    Ищет указанный массив указанный объект, используя алгоритм двоичного поиска. Массив должен быть сортирован в порядок по возрастанию согласно естественному упорядочиванию его элементов (как sort(Object[]) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. (Если массив содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа), он не может быть сортирован согласно естественному упорядочиванию его элементов, следовательно результаты неопределены.), Если массив содержит многократные элементы, равные указанному объекту, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента, больше чем ключ, или a.length, если все элементы в массиве являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
    
    Броски:
    
    ClassCastException - если ключ поиска не сопоставим с элементами массива.
  - binarySearch
```
public static int binarySearch(Object[] a,
                               int fromIndex,
                               int toIndex,
                               Object key)
```
    Ищет диапазон указанного массива для указанного объекта, используя алгоритм двоичного поиска. Диапазон должен быть сортирован в порядок по возрастанию согласно естественному упорядочиванию его элементов (как sort(Object[], int, int) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. (Если диапазон содержит элементы, которые не взаимно сопоставимы (например, строки и целые числа), он не может быть сортирован согласно естественному упорядочиванию его элементов, следовательно результаты неопределены.), Если диапазон содержит многократные элементы, равные указанному объекту, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    fromIndex - индексирование первого элемента (включительно), чтобы искаться
    
    toIndex - индексирование последнего элемента (монопольного), чтобы искаться
    
    key - значение, которое будет разыскиваться
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве в пределах указанного диапазона; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента в диапазоне, больше чем ключ, или toIndex, если все элементы в диапазоне являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
    
    Броски:
    
    ClassCastException - если ключ поиска не сопоставим с элементами массива в пределах указанного диапазона.
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 or toIndex > a.length
    
    С тех пор:
    
    1.6
  - binarySearch
```
public static <T> int binarySearch(T[] a,
                                   T key,
                                   Comparator<? super T> c)
```
    Ищет указанный массив указанный объект, используя алгоритм двоичного поиска. Массив должен быть сортирован в порядок по возрастанию согласно указанному компаратору (как sort(T[], Comparator) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если массив содержит многократные элементы, равные указанному объекту, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    key - значение, которое будет разыскиваться
    
    c - компаратор, которым упорядочивают массиву. Значение null указывает, что естественное упорядочивание элементов должно использоваться.
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента, больше чем ключ, или a.length, если все элементы в массиве являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
    
    Броски:
    
    ClassCastException - если массив содержит элементы, которые не являются взаимно сопоставимым использованием указанного компаратора, или ключ поиска не сопоставим с элементами массива, использующего этот компаратор.
  - binarySearch
```
public static <T> int binarySearch(T[] a,
                                   int fromIndex,
                                   int toIndex,
                                   T key,
                                   Comparator<? super T> c)
```
    Ищет диапазон указанного массива для указанного объекта, используя алгоритм двоичного поиска. Диапазон должен быть сортирован в порядок по возрастанию согласно указанному компаратору (как sort(T[], int, int, Comparator) метод) до выполнения этого вызова. Если это не сортируется, результаты неопределены. Если диапазон содержит многократные элементы, равные указанному объекту, нет никакой гарантии, которой будет найден.
    
    Параметры:
    
    a - массив, который будет искаться
    
    fromIndex - индексирование первого элемента (включительно), чтобы искаться
    
    toIndex - индексирование последнего элемента (монопольного), чтобы искаться
    
    key - значение, которое будет разыскиваться
    
    c - компаратор, которым упорядочивают массиву. Значение null указывает, что естественное упорядочивание элементов должно использоваться.
    
    Возвраты:
    
    индексируйте ключа поиска, если он содержится в массиве в пределах указанного диапазона; иначе, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индексирование первого элемента в диапазоне, больше чем ключ, или toIndex, если все элементы в диапазоне являются меньше чем указанный ключ. Отметьте, что это гарантирует, что возвращаемое значение будет> = 0, если и только если ключ находится.
    
    Броски:
    
    ClassCastException - если диапазон содержит элементы, которые не являются взаимно сопоставимым использованием указанного компаратора, или ключ поиска не сопоставим с элементами в диапазоне, используя этот компаратор.
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 or toIndex > a.length
    
    С тех пор:
    
    1.6
  - равняется
```
public static boolean equals(long[] a,
                             long[] a2)
```
    true возвратов, если два указанных массива longs равны друг другу. Два массива считают равными, если оба массива содержат то же самое число элементов, и все соответствующие пары элементов в двух массивах равны. Другими словами два массива равны, если они содержат те же самые элементы в том же самом порядке. Кроме того, две ссылки массива считают равными, если оба - null.
    
    Параметры:
    
    a - один массив, который будет протестирован на равенство
    
    a2 - другой массив, который будет протестирован на равенство
    
    Возвраты:
    
    true, если два массива равны
  - равняется
```
public static boolean equals(int[] a,
                             int[] a2)
```
    true возвратов, если два указанных массива ints равны друг другу. Два массива считают равными, если оба массива содержат то же самое число элементов, и все соответствующие пары элементов в двух массивах равны. Другими словами два массива равны, если они содержат те же самые элементы в том же самом порядке. Кроме того, две ссылки массива считают равными, если оба - null.
    
    Параметры:
    
    a - один массив, который будет протестирован на равенство
    
    a2 - другой массив, который будет протестирован на равенство
    
    Возвраты:
    
    true, если два массива равны
  - равняется
```
public static boolean equals(short[] a,
                             short[] a2)
```
    true возвратов, если два указанных массива шорт равны друг другу. Два массива считают равными, если оба массива содержат то же самое число элементов, и все соответствующие пары элементов в двух массивах равны. Другими словами два массива равны, если они содержат те же самые элементы в том же самом порядке. Кроме того, две ссылки массива считают равными, если оба - null.
    
    Параметры:
    
    a - один массив, который будет протестирован на равенство
    
    a2 - другой массив, который будет протестирован на равенство
    
    Возвраты:
    
    true, если два массива равны
  - равняется
```
public static boolean equals(char[] a,
                             char[] a2)
```
    true возвратов, если два указанных массива случайных работ равны друг другу. Два массива считают равными, если оба массива содержат то же самое число элементов, и все соответствующие пары элементов в двух массивах равны. Другими словами два массива равны, если они содержат те же самые элементы в том же самом порядке. Кроме того, две ссылки массива считают равными, если оба - null.
    
    Параметры:
    
    a - один массив, который будет протестирован на равенство
    
    a2 - другой массив, который будет протестирован на равенство
    
    Возвраты:
    
    true, если два массива равны
  - равняется
```
public static boolean equals(byte[] a,
                             byte[] a2)
```
    true возвратов, если два указанных массива байтов равны друг другу. Два массива считают равными, если оба массива содержат то же самое число элементов, и все соответствующие пары элементов в двух массивах равны. Другими словами два массива равны, если они содержат те же самые элементы в том же самом порядке. Кроме того, две ссылки массива считают равными, если оба - null.
    
    Параметры:
    
    a - один массив, который будет протестирован на равенство
    
    a2 - другой массив, который будет протестирован на равенство
    
    Возвраты:
    
    true, если два массива равны
  - равняется
```
public static boolean equals(boolean[] a,
                             boolean[] a2)
```
    true возвратов, если два указанных массива булевских переменных равны друг другу. Два массива считают равными, если оба массива содержат то же самое число элементов, и все соответствующие пары элементов в двух массивах равны. Другими словами два массива равны, если они содержат те же самые элементы в том же самом порядке. Кроме того, две ссылки массива считают равными, если оба - null.
    
    Параметры:
    
    a - один массив, который будет протестирован на равенство
    
    a2 - другой массив, который будет протестирован на равенство
    
    Возвраты:
    
    true, если два массива равны
  - равняется
```
public static boolean equals(double[] a,
                             double[] a2)
```
    Возвраты true, если два указанных массива удваивается, равны друг другу. Два массива считают равными, если оба массива содержат то же самое число элементов, и все соответствующие пары элементов в двух массивах равны. Другими словами два массива равны, если они содержат те же самые элементы в том же самом порядке. Кроме того, две ссылки массива считают равными, если оба - null.
    Два удваивает d1, и d2 считаются равными если:
```
    new Double(d1).equals(new Double(d2))
```
    (В отличие от оператора ==, этот метод полагает, что NaN равняется себе, и 0.0d неравный-0.0d.)
    Параметры:
    
    a - один массив, который будет протестирован на равенство
    
    a2 - другой массив, который будет протестирован на равенство
    
    Возвраты:
    
    true, если два массива равны
    
    См. Также:
    
    Double.equals(Object)
  - равняется
```
public static boolean equals(float[] a,
                             float[] a2)
```
    true возвратов, если два указанных массива плаваний равны друг другу. Два массива считают равными, если оба массива содержат то же самое число элементов, и все соответствующие пары элементов в двух массивах равны. Другими словами два массива равны, если они содержат те же самые элементы в том же самом порядке. Кроме того, две ссылки массива считают равными, если оба - null.
    Два плавания f1 и f2 считают равными если:
```
    new Float(f1).equals(new Float(f2))
```
    (В отличие от оператора ==, этот метод полагает, что NaN равняется себе, и 0.0f неравный-0.0f.)
    Параметры:
    
    a - один массив, который будет протестирован на равенство
    
    a2 - другой массив, который будет протестирован на равенство
    
    Возвраты:
    
    true, если два массива равны
    
    См. Также:
    
    Float.equals(Object)
  - равняется
```
public static boolean equals(Object[] a,
                             Object[] a2)
```
    true возвратов, если два указанных массива Объектов равны друг другу. Два массива считают равными, если оба массива содержат то же самое число элементов, и все соответствующие пары элементов в двух массивах равны. Два объекта e1 и e2 считают равными если (e1==null ? e2==null : e1.equals(e2)). Другими словами два массива равны, если они содержат те же самые элементы в том же самом порядке. Кроме того, две ссылки массива считают равными, если оба - null.
    
    Параметры:
    
    a - один массив, который будет протестирован на равенство
    
    a2 - другой массив, который будет протестирован на равенство
    
    Возвраты:
    
    true, если два массива равны
  - заливка
```
public static void fill(long[] a,
                        long val)
```
    Присваивает указанное длинное значение каждому элементу указанного массива longs.
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    val - значение, которое будет сохранено во всех элементах массива
  - заливка
```
public static void fill(long[] a,
                        int fromIndex,
                        int toIndex,
                        long val)
```
    Присваивает указанное длинное значение каждому элементу указанного диапазона указанного массива longs. Диапазон, чтобы быть заполненным расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, чтобы быть заполненным пуст.)
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть заполненным указанным значением
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть заполненным указанным значением
    
    val - значение, которое будет сохранено во всех элементах массива
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - заливка
```
public static void fill(int[] a,
                        int val)
```
    Присваивает указанное международное значение каждому элементу указанного массива ints.
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    val - значение, которое будет сохранено во всех элементах массива
  - заливка
```
public static void fill(int[] a,
                        int fromIndex,
                        int toIndex,
                        int val)
```
    Присваивает указанное международное значение каждому элементу указанного диапазона указанного массива ints. Диапазон, чтобы быть заполненным расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, чтобы быть заполненным пуст.)
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть заполненным указанным значением
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть заполненным указанным значением
    
    val - значение, которое будет сохранено во всех элементах массива
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - заливка
```
public static void fill(short[] a,
                        short val)
```
    Присваивает указанное короткое значение каждому элементу указанного массива шорт.
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    val - значение, которое будет сохранено во всех элементах массива
  - заливка
```
public static void fill(short[] a,
                        int fromIndex,
                        int toIndex,
                        short val)
```
    Присваивает указанное короткое значение каждому элементу указанного диапазона указанного массива шорт. Диапазон, чтобы быть заполненным расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, чтобы быть заполненным пуст.)
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть заполненным указанным значением
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть заполненным указанным значением
    
    val - значение, которое будет сохранено во всех элементах массива
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - заливка
```
public static void fill(char[] a,
                        char val)
```
    Присваивает указанное значение случайной работы каждому элементу указанного массива случайных работ.
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    val - значение, которое будет сохранено во всех элементах массива
  - заливка
```
public static void fill(char[] a,
                        int fromIndex,
                        int toIndex,
                        char val)
```
    Присваивает указанное значение случайной работы каждому элементу указанного диапазона указанного массива случайных работ. Диапазон, чтобы быть заполненным расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, чтобы быть заполненным пуст.)
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть заполненным указанным значением
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть заполненным указанным значением
    
    val - значение, которое будет сохранено во всех элементах массива
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - заливка
```
public static void fill(byte[] a,
                        byte val)
```
    Присваивает указанное значение байта каждому элементу указанного массива байтов.
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    val - значение, которое будет сохранено во всех элементах массива
  - заливка
```
public static void fill(byte[] a,
                        int fromIndex,
                        int toIndex,
                        byte val)
```
    Присваивает указанное значение байта каждому элементу указанного диапазона указанного массива байтов. Диапазон, чтобы быть заполненным расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, чтобы быть заполненным пуст.)
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть заполненным указанным значением
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть заполненным указанным значением
    
    val - значение, которое будет сохранено во всех элементах массива
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - заливка
```
public static void fill(boolean[] a,
                        boolean val)
```
    Присваивает указанное булево значение каждому элементу указанного массива булевских переменных.
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    val - значение, которое будет сохранено во всех элементах массива
  - заливка
```
public static void fill(boolean[] a,
                        int fromIndex,
                        int toIndex,
                        boolean val)
```
    Присваивает указанное булево значение каждому элементу указанного диапазона указанного массива булевских переменных. Диапазон, чтобы быть заполненным расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, чтобы быть заполненным пуст.)
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть заполненным указанным значением
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть заполненным указанным значением
    
    val - значение, которое будет сохранено во всех элементах массива
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - заливка
```
public static void fill(double[] a,
                        double val)
```
    Присваивается указанное двойное значение к каждому элементу указанного массива удваивается.
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    val - значение, которое будет сохранено во всех элементах массива
  - заливка
```
public static void fill(double[] a,
                        int fromIndex,
                        int toIndex,
                        double val)
```
    Присваивается указанное двойное значение к каждому элементу указанного диапазона указанного массива удваивается. Диапазон, чтобы быть заполненным расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, чтобы быть заполненным пуст.)
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть заполненным указанным значением
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть заполненным указанным значением
    
    val - значение, которое будет сохранено во всех элементах массива
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - заливка
```
public static void fill(float[] a,
                        float val)
```
    Присваивает указанное значение плавающее каждому элементу указанного массива плаваний.
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    val - значение, которое будет сохранено во всех элементах массива
  - заливка
```
public static void fill(float[] a,
                        int fromIndex,
                        int toIndex,
                        float val)
```
    Присваивает указанное значение плавающее каждому элементу указанного диапазона указанного массива плаваний. Диапазон, чтобы быть заполненным расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, чтобы быть заполненным пуст.)
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть заполненным указанным значением
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть заполненным указанным значением
    
    val - значение, которое будет сохранено во всех элементах массива
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
  - заливка
```
public static void fill(Object[] a,
                        Object val)
```
    Присваивает указанную Ссылку на объект на каждый элемент указанного массива Объектов.
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    val - значение, которое будет сохранено во всех элементах массива
    
    Броски:
    
    ArrayStoreException - если указанное значение не имеет типа времени выполнения, который может быть сохранен в указанном массиве
  - заливка
```
public static void fill(Object[] a,
                        int fromIndex,
                        int toIndex,
                        Object val)
```
    Присваивает указанную Ссылку на объект на каждый элемент указанного диапазона указанного массива Объектов. Диапазон, чтобы быть заполненным расширяется от, индексируют fromIndex, включительно, чтобы индексировать toIndex, монопольный. (Если fromIndex==toIndex, диапазон, чтобы быть заполненным пуст.)
    
    Параметры:
    
    a - массив, чтобы быть заполненным
    
    fromIndex - индексирование первого элемента (включительно), чтобы быть заполненным указанным значением
    
    toIndex - индексирование последнего элемента (монопольного), чтобы быть заполненным указанным значением
    
    val - значение, которое будет сохранено во всех элементах массива
    
    Броски:
    
    IllegalArgumentException - если fromIndex > toIndex
    
    ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length
    
    ArrayStoreException - если указанное значение не имеет типа времени выполнения, который может быть сохранен в указанном массиве
  - copyOf
```
public static <T> T[] copyOf(T[] original,
                             int newLength)
```
    Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина. Для всех индексов, которые допустимы и в исходном массиве и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не оригинале, копия будет содержать null. Такие индексы будут существовать, если и только если указанная длина больше чем тот из исходного массива. Получающийся массив имеет точно тот же самый class как исходный массив.
    
    Параметры:
    
    original - массив, который будет скопирован
    
    newLength - длина копии, которая будет возвращена
    
    Возвраты:
    
    копия исходного массива, усеченного или дополненного нулями, чтобы получить указанную длину
    
    Броски:
    
    NegativeArraySizeException - если newLength отрицателен
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOf
```
public static <T,U> T[] copyOf(U[] original,
                               int newLength,
                               Class<? extends T[]> newType)
```
    Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина. Для всех индексов, которые допустимы и в исходном массиве и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не оригинале, копия будет содержать null. Такие индексы будут существовать, если и только если указанная длина больше чем тот из исходного массива. Получающийся массив имеет class newType.
    
    Параметры:
    
    original - массив, который будет скопирован
    
    newLength - длина копии, которая будет возвращена
    
    newType - class копии, которая будет возвращена
    
    Возвраты:
    
    копия исходного массива, усеченного или дополненного нулями, чтобы получить указанную длину
    
    Броски:
    
    NegativeArraySizeException - если newLength отрицателен
    
    NullPointerException - если original является нулем
    
    ArrayStoreException - если элемент, скопированный с original, не имеет типа времени выполнения, который может быть сохранен в массиве class newType
    
    С тех пор:
    
    1.6
  - copyOf
```
public static byte[] copyOf(byte[] original,
                            int newLength)
```
    Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина. Для всех индексов, которые допустимы и в исходном массиве и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не оригинале, копия будет содержать (byte)0. Такие индексы будут существовать, если и только если указанная длина больше чем тот из исходного массива.
    
    Параметры:
    
    original - массив, который будет скопирован
    
    newLength - длина копии, которая будет возвращена
    
    Возвраты:
    
    копия исходного массива, усеченного или дополненного нулями, чтобы получить указанную длину
    
    Броски:
    
    NegativeArraySizeException - если newLength отрицателен
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOf
```
public static short[] copyOf(short[] original,
                             int newLength)
```
    Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина. Для всех индексов, которые допустимы и в исходном массиве и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не оригинале, копия будет содержать (short)0. Такие индексы будут существовать, если и только если указанная длина больше чем тот из исходного массива.
    
    Параметры:
    
    original - массив, который будет скопирован
    
    newLength - длина копии, которая будет возвращена
    
    Возвраты:
    
    копия исходного массива, усеченного или дополненного нулями, чтобы получить указанную длину
    
    Броски:
    
    NegativeArraySizeException - если newLength отрицателен
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOf
```
public static int[] copyOf(int[] original,
                           int newLength)
```
    Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина. Для всех индексов, которые допустимы и в исходном массиве и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не оригинале, копия будет содержать 0. Такие индексы будут существовать, если и только если указанная длина больше чем тот из исходного массива.
    
    Параметры:
    
    original - массив, который будет скопирован
    
    newLength - длина копии, которая будет возвращена
    
    Возвраты:
    
    копия исходного массива, усеченного или дополненного нулями, чтобы получить указанную длину
    
    Броски:
    
    NegativeArraySizeException - если newLength отрицателен
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOf
```
public static long[] copyOf(long[] original,
                            int newLength)
```
    Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина. Для всех индексов, которые допустимы и в исходном массиве и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не оригинале, копия будет содержать 0L. Такие индексы будут существовать, если и только если указанная длина больше чем тот из исходного массива.
    
    Параметры:
    
    original - массив, который будет скопирован
    
    newLength - длина копии, которая будет возвращена
    
    Возвраты:
    
    копия исходного массива, усеченного или дополненного нулями, чтобы получить указанную длину
    
    Броски:
    
    NegativeArraySizeException - если newLength отрицателен
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOf
```
public static char[] copyOf(char[] original,
                            int newLength)
```
    Копирует указанный массив, усекая или дополняя нулевыми символами (в случае необходимости), таким образом, у копии есть указанная длина. Для всех индексов, которые допустимы и в исходном массиве и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не оригинале, копия будет содержать '\\u000'. Такие индексы будут существовать, если и только если указанная длина больше чем тот из исходного массива.
    
    Параметры:
    
    original - массив, который будет скопирован
    
    newLength - длина копии, которая будет возвращена
    
    Возвраты:
    
    копия исходного массива, усеченного или дополненного нулевыми символами, чтобы получить указанную длину
    
    Броски:
    
    NegativeArraySizeException - если newLength отрицателен
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOf
```
public static float[] copyOf(float[] original,
                             int newLength)
```
    Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина. Для всех индексов, которые допустимы и в исходном массиве и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не оригинале, копия будет содержать 0f. Такие индексы будут существовать, если и только если указанная длина больше чем тот из исходного массива.
    
    Параметры:
    
    original - массив, который будет скопирован
    
    newLength - длина копии, которая будет возвращена
    
    Возвраты:
    
    копия исходного массива, усеченного или дополненного нулями, чтобы получить указанную длину
    
    Броски:
    
    NegativeArraySizeException - если newLength отрицателен
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOf
```
public static double[] copyOf(double[] original,
                              int newLength)
```
    Копирует указанный массив, усекая или дополняя нулями (в случае необходимости), таким образом, у копии есть указанная длина. Для всех индексов, которые допустимы и в исходном массиве и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не оригинале, копия будет содержать 0d. Такие индексы будут существовать, если и только если указанная длина больше чем тот из исходного массива.
    
    Параметры:
    
    original - массив, который будет скопирован
    
    newLength - длина копии, которая будет возвращена
    
    Возвраты:
    
    копия исходного массива, усеченного или дополненного нулями, чтобы получить указанную длину
    
    Броски:
    
    NegativeArraySizeException - если newLength отрицателен
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOf
```
public static boolean[] copyOf(boolean[] original,
                               int newLength)
```
    Копирует указанный массив, усекая или дополняя false (в случае необходимости), таким образом, у копии есть указанная длина. Для всех индексов, которые допустимы и в исходном массиве и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не оригинале, копия будет содержать false. Такие индексы будут существовать, если и только если указанная длина больше чем тот из исходного массива.
    
    Параметры:
    
    original - массив, который будет скопирован
    
    newLength - длина копии, которая будет возвращена
    
    Возвраты:
    
    копия исходного массива, усеченного или дополненного ложными элементами, чтобы получить указанную длину
    
    Броски:
    
    NegativeArraySizeException - если newLength отрицателен
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOfRange
```
public static <T> T[] copyOfRange(T[] original,
                                  int from,
                                  int to)
```
    Копирует указанный диапазон указанного массива в новый массив. Начальная буква индексирует диапазона (from), должен находиться между нулем и original.length, включительно. Значение в original[from] не помещается в начальный элемент копии (если from == original.length или from == to). Значения от последующих элементов в исходном массиве помещаются в последующие элементы в копии. Финал индексирует диапазона (to), который должен быть больше чем или равным from, может быть больше чем original.length, когда null помещается во все элементы копии, чья индексируют, больше чем или равен original.length - from. Длиной возвращенного массива будет to - from.
    Получающийся массив имеет точно тот же самый class как исходный массив.
    
    Параметры:
    
    original - массив, с которого должен быть скопирован диапазон
    
    from - начальная буква индексирует диапазона, который будет скопирован, включительно
    
    to - финал индексирует диапазона, который будет скопирован, монопольный. (Это индексирует, может лечь вне массива.)
    
    Возвраты:
    
    новый массив, содержащий указанный диапазон от исходного массива, усеченного или дополненного нулями, чтобы получить необходимую длину
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если from < 0 или from > original.length
    
    IllegalArgumentException - если from > to
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOfRange
```
public static <T,U> T[] copyOfRange(U[] original,
                                    int from,
                                    int to,
                                    Class<? extends T[]> newType)
```
    Копирует указанный диапазон указанного массива в новый массив. Начальная буква индексирует диапазона (from), должен находиться между нулем и original.length, включительно. Значение в original[from] не помещается в начальный элемент копии (если from == original.length или from == to). Значения от последующих элементов в исходном массиве помещаются в последующие элементы в копии. Финал индексирует диапазона (to), который должен быть больше чем или равным from, может быть больше чем original.length, когда null помещается во все элементы копии, чья индексируют, больше чем или равен original.length - from. Длиной возвращенного массива будет to - from. Получающийся массив имеет class newType.
    
    Параметры:
    
    original - массив, с которого должен быть скопирован диапазон
    
    from - начальная буква индексирует диапазона, который будет скопирован, включительно
    
    to - финал индексирует диапазона, который будет скопирован, монопольный. (Это индексирует, может лечь вне массива.)
    
    newType - class копии, которая будет возвращена
    
    Возвраты:
    
    новый массив, содержащий указанный диапазон от исходного массива, усеченного или дополненного нулями, чтобы получить необходимую длину
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если from < 0 или from > original.length
    
    IllegalArgumentException - если from > to
    
    NullPointerException - если original является нулем
    
    ArrayStoreException - если элемент, скопированный с original, не имеет типа времени выполнения, который может быть сохранен в массиве class newType.
    
    С тех пор:
    
    1.6
  - copyOfRange
```
public static byte[] copyOfRange(byte[] original,
                                 int from,
                                 int to)
```
    Копирует указанный диапазон указанного массива в новый массив. Начальная буква индексирует диапазона (from), должен находиться между нулем и original.length, включительно. Значение в original[from] не помещается в начальный элемент копии (если from == original.length или from == to). Значения от последующих элементов в исходном массиве помещаются в последующие элементы в копии. Финал индексирует диапазона (to), который должен быть больше чем или равным from, может быть больше чем original.length, когда (byte)0 помещается во все элементы копии, чья индексируют, больше чем или равен original.length - from. Длиной возвращенного массива будет to - from.
    
    Параметры:
    
    original - массив, с которого должен быть скопирован диапазон
    
    from - начальная буква индексирует диапазона, который будет скопирован, включительно
    
    to - финал индексирует диапазона, который будет скопирован, монопольный. (Это индексирует, может лечь вне массива.)
    
    Возвраты:
    
    новый массив, содержащий указанный диапазон от исходного массива, усеченного или дополненного нулями, чтобы получить необходимую длину
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если from < 0 или from > original.length
    
    IllegalArgumentException - если from > to
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOfRange
```
public static short[] copyOfRange(short[] original,
                                  int from,
                                  int to)
```
    Копирует указанный диапазон указанного массива в новый массив. Начальная буква индексирует диапазона (from), должен находиться между нулем и original.length, включительно. Значение в original[from] не помещается в начальный элемент копии (если from == original.length или from == to). Значения от последующих элементов в исходном массиве помещаются в последующие элементы в копии. Финал индексирует диапазона (to), который должен быть больше чем или равным from, может быть больше чем original.length, когда (short)0 помещается во все элементы копии, чья индексируют, больше чем или равен original.length - from. Длиной возвращенного массива будет to - from.
    
    Параметры:
    
    original - массив, с которого должен быть скопирован диапазон
    
    from - начальная буква индексирует диапазона, который будет скопирован, включительно
    
    to - финал индексирует диапазона, который будет скопирован, монопольный. (Это индексирует, может лечь вне массива.)
    
    Возвраты:
    
    новый массив, содержащий указанный диапазон от исходного массива, усеченного или дополненного нулями, чтобы получить необходимую длину
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если from < 0 или from > original.length
    
    IllegalArgumentException - если from > to
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOfRange
```
public static int[] copyOfRange(int[] original,
                                int from,
                                int to)
```
    Копирует указанный диапазон указанного массива в новый массив. Начальная буква индексирует диапазона (from), должен находиться между нулем и original.length, включительно. Значение в original[from] не помещается в начальный элемент копии (если from == original.length или from == to). Значения от последующих элементов в исходном массиве помещаются в последующие элементы в копии. Финал индексирует диапазона (to), который должен быть больше чем или равным from, может быть больше чем original.length, когда 0 помещается во все элементы копии, чья индексируют, больше чем или равен original.length - from. Длиной возвращенного массива будет to - from.
    
    Параметры:
    
    original - массив, с которого должен быть скопирован диапазон
    
    from - начальная буква индексирует диапазона, который будет скопирован, включительно
    
    to - финал индексирует диапазона, который будет скопирован, монопольный. (Это индексирует, может лечь вне массива.)
    
    Возвраты:
    
    новый массив, содержащий указанный диапазон от исходного массива, усеченного или дополненного нулями, чтобы получить необходимую длину
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если from < 0 или from > original.length
    
    IllegalArgumentException - если from > to
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOfRange
```
public static long[] copyOfRange(long[] original,
                                 int from,
                                 int to)
```
    Копирует указанный диапазон указанного массива в новый массив. Начальная буква индексирует диапазона (from), должен находиться между нулем и original.length, включительно. Значение в original[from] не помещается в начальный элемент копии (если from == original.length или from == to). Значения от последующих элементов в исходном массиве помещаются в последующие элементы в копии. Финал индексирует диапазона (to), который должен быть больше чем или равным from, может быть больше чем original.length, когда 0L помещается во все элементы копии, чья индексируют, больше чем или равен original.length - from. Длиной возвращенного массива будет to - from.
    
    Параметры:
    
    original - массив, с которого должен быть скопирован диапазон
    
    from - начальная буква индексирует диапазона, который будет скопирован, включительно
    
    to - финал индексирует диапазона, который будет скопирован, монопольный. (Это индексирует, может лечь вне массива.)
    
    Возвраты:
    
    новый массив, содержащий указанный диапазон от исходного массива, усеченного или дополненного нулями, чтобы получить необходимую длину
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если from < 0 или from > original.length
    
    IllegalArgumentException - если from > to
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOfRange
```
public static char[] copyOfRange(char[] original,
                                 int from,
                                 int to)
```
    Копирует указанный диапазон указанного массива в новый массив. Начальная буква индексирует диапазона (from), должен находиться между нулем и original.length, включительно. Значение в original[from] не помещается в начальный элемент копии (если from == original.length или from == to). Значения от последующих элементов в исходном массиве помещаются в последующие элементы в копии. Финал индексирует диапазона (to), который должен быть больше чем или равным from, может быть больше чем original.length, когда '\\u000' помещается во все элементы копии, чья индексируют, больше чем или равен original.length - from. Длиной возвращенного массива будет to - from.
    
    Параметры:
    
    original - массив, с которого должен быть скопирован диапазон
    
    from - начальная буква индексирует диапазона, который будет скопирован, включительно
    
    to - финал индексирует диапазона, который будет скопирован, монопольный. (Это индексирует, может лечь вне массива.)
    
    Возвраты:
    
    новый массив, содержащий указанный диапазон от исходного массива, усеченного или дополненного нулевыми символами, чтобы получить необходимую длину
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если from < 0 или from > original.length
    
    IllegalArgumentException - если from > to
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOfRange
```
public static float[] copyOfRange(float[] original,
                                  int from,
                                  int to)
```
    Копирует указанный диапазон указанного массива в новый массив. Начальная буква индексирует диапазона (from), должен находиться между нулем и original.length, включительно. Значение в original[from] не помещается в начальный элемент копии (если from == original.length или from == to). Значения от последующих элементов в исходном массиве помещаются в последующие элементы в копии. Финал индексирует диапазона (to), который должен быть больше чем или равным from, может быть больше чем original.length, когда 0f помещается во все элементы копии, чья индексируют, больше чем или равен original.length - from. Длиной возвращенного массива будет to - from.
    
    Параметры:
    
    original - массив, с которого должен быть скопирован диапазон
    
    from - начальная буква индексирует диапазона, который будет скопирован, включительно
    
    to - финал индексирует диапазона, который будет скопирован, монопольный. (Это индексирует, может лечь вне массива.)
    
    Возвраты:
    
    новый массив, содержащий указанный диапазон от исходного массива, усеченного или дополненного нулями, чтобы получить необходимую длину
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если from < 0 или from > original.length
    
    IllegalArgumentException - если from > to
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOfRange
```
public static double[] copyOfRange(double[] original,
                                   int from,
                                   int to)
```
    Копирует указанный диапазон указанного массива в новый массив. Начальная буква индексирует диапазона (from), должен находиться между нулем и original.length, включительно. Значение в original[from] не помещается в начальный элемент копии (если from == original.length или from == to). Значения от последующих элементов в исходном массиве помещаются в последующие элементы в копии. Финал индексирует диапазона (to), который должен быть больше чем или равным from, может быть больше чем original.length, когда 0d помещается во все элементы копии, чья индексируют, больше чем или равен original.length - from. Длиной возвращенного массива будет to - from.
    
    Параметры:
    
    original - массив, с которого должен быть скопирован диапазон
    
    from - начальная буква индексирует диапазона, который будет скопирован, включительно
    
    to - финал индексирует диапазона, который будет скопирован, монопольный. (Это индексирует, может лечь вне массива.)
    
    Возвраты:
    
    новый массив, содержащий указанный диапазон от исходного массива, усеченного или дополненного нулями, чтобы получить необходимую длину
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если from < 0 или from > original.length
    
    IllegalArgumentException - если from > to
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - copyOfRange
```
public static boolean[] copyOfRange(boolean[] original,
                                    int from,
                                    int to)
```
    Копирует указанный диапазон указанного массива в новый массив. Начальная буква индексирует диапазона (from), должен находиться между нулем и original.length, включительно. Значение в original[from] не помещается в начальный элемент копии (если from == original.length или from == to). Значения от последующих элементов в исходном массиве помещаются в последующие элементы в копии. Финал индексирует диапазона (to), который должен быть больше чем или равным from, может быть больше чем original.length, когда false помещается во все элементы копии, чья индексируют, больше чем или равен original.length - from. Длиной возвращенного массива будет to - from.
    
    Параметры:
    
    original - массив, с которого должен быть скопирован диапазон
    
    from - начальная буква индексирует диапазона, который будет скопирован, включительно
    
    to - финал индексирует диапазона, который будет скопирован, монопольный. (Это индексирует, может лечь вне массива.)
    
    Возвраты:
    
    новый массив, содержащий указанный диапазон от исходного массива, усеченного или дополненного ложными элементами, чтобы получить необходимую длину
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если from < 0 или from > original.length
    
    IllegalArgumentException - если from > to
    
    NullPointerException - если original является нулем
    
    С тех пор:
    
    1.6
  - asList
```
@SafeVarargs
public static <T> List<T> asList(T... a)
```
    Возвращает список фиксированного размера, поддержанный указанным массивом. (Изменения к возвращенному списку "пишут через" в массив.) Этот метод действует как мост между основанными на массиве и основанными на наборе API в комбинации с Collection.toArray(). Возвращенный список сериализуем и реализации RandomAccess.
    Этот метод также обеспечивает удобный способ создать список фиксированного размера, инициализированный, чтобы содержать несколько элементов:
```
     List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
 
```
    Параметры:
    
    a - массив, которым будет поддержан список
    
    Возвраты:
    
    представление списка указанного массива
  - хэш-код
```
public static int hashCode(long[] a)
```
    Возвращает хэш-код, основанный на содержании указанного массива. Для любых двух массивов long a и b так, что Arrays.equals(a, b), это также имеет место тот Arrays.hashCode(a) == Arrays.hashCode(b).
    Значение, возвращенное этим методом, является тем же самым значением, которое было бы получено, вызывая hashCode метод на a List содержа последовательность Long экземпляры, представляющие элементы a в том же самом порядке. Если a является null, этот метод возвращается 0.
    
    Параметры:
    
    a - массив, чье значение хэш-функции, чтобы вычислить
    
    Возвраты:
    
    основанный на контенте хэш-код для a
    
    С тех пор:
    
    1.5
  - хэш-код
```
public static int hashCode(int[] a)
```
    Возвращает хэш-код, основанный на содержании указанного массива. Поскольку любые два ненулевых int выстраивает a и b так, что Arrays.equals(a, b), это также имеет место тот Arrays.hashCode(a) == Arrays.hashCode(b).
    Значение, возвращенное этим методом, является тем же самым значением, которое было бы получено, вызывая hashCode метод на a List содержа последовательность Integer экземпляры, представляющие элементы a в том же самом порядке. Если a является null, этот метод возвращается 0.
    
    Параметры:
    
    a - массив, чье значение хэш-функции, чтобы вычислить
    
    Возвраты:
    
    основанный на контенте хэш-код для a
    
    С тех пор:
    
    1.5
  - хэш-код
```
public static int hashCode(short[] a)
```
    Возвращает хэш-код, основанный на содержании указанного массива. Для любых двух массивов short a и b так, что Arrays.equals(a, b), это также имеет место тот Arrays.hashCode(a) == Arrays.hashCode(b).
    Значение, возвращенное этим методом, является тем же самым значением, которое было бы получено, вызывая hashCode метод на a List содержа последовательность Short экземпляры, представляющие элементы a в том же самом порядке. Если a является null, этот метод возвращается 0.
    
    Параметры:
    
    a - массив, чье значение хэш-функции, чтобы вычислить
    
    Возвраты:
    
    основанный на контенте хэш-код для a
    
    С тех пор:
    
    1.5
  - хэш-код
```
public static int hashCode(char[] a)
```
    Возвращает хэш-код, основанный на содержании указанного массива. Для любых двух массивов char a и b так, что Arrays.equals(a, b), это также имеет место тот Arrays.hashCode(a) == Arrays.hashCode(b).
    Значение, возвращенное этим методом, является тем же самым значением, которое было бы получено, вызывая hashCode метод на a List содержа последовательность Character экземпляры, представляющие элементы a в том же самом порядке. Если a является null, этот метод возвращается 0.
    
    Параметры:
    
    a - массив, чье значение хэш-функции, чтобы вычислить
    
    Возвраты:
    
    основанный на контенте хэш-код для a
    
    С тех пор:
    
    1.5
  - хэш-код
```
public static int hashCode(byte[] a)
```
    Возвращает хэш-код, основанный на содержании указанного массива. Для любых двух массивов byte a и b так, что Arrays.equals(a, b), это также имеет место тот Arrays.hashCode(a) == Arrays.hashCode(b).
    Значение, возвращенное этим методом, является тем же самым значением, которое было бы получено, вызывая hashCode метод на a List содержа последовательность Byte экземпляры, представляющие элементы a в том же самом порядке. Если a является null, этот метод возвращается 0.
    
    Параметры:
    
    a - массив, чье значение хэш-функции, чтобы вычислить
    
    Возвраты:
    
    основанный на контенте хэш-код для a
    
    С тех пор:
    
    1.5
  - хэш-код
```
public static int hashCode(boolean[] a)
```
    Возвращает хэш-код, основанный на содержании указанного массива. Для любых двух массивов boolean a и b так, что Arrays.equals(a, b), это также имеет место тот Arrays.hashCode(a) == Arrays.hashCode(b).
    Значение, возвращенное этим методом, является тем же самым значением, которое было бы получено, вызывая hashCode метод на a List содержа последовательность Boolean экземпляры, представляющие элементы a в том же самом порядке. Если a является null, этот метод возвращается 0.
    
    Параметры:
    
    a - массив, чье значение хэш-функции, чтобы вычислить
    
    Возвраты:
    
    основанный на контенте хэш-код для a
    
    С тех пор:
    
    1.5
  - хэш-код
```
public static int hashCode(float[] a)
```
    Возвращает хэш-код, основанный на содержании указанного массива. Для любых двух массивов float a и b так, что Arrays.equals(a, b), это также имеет место тот Arrays.hashCode(a) == Arrays.hashCode(b).
    Значение, возвращенное этим методом, является тем же самым значением, которое было бы получено, вызывая hashCode метод на a List содержа последовательность Float экземпляры, представляющие элементы a в том же самом порядке. Если a является null, этот метод возвращается 0.
    
    Параметры:
    
    a - массив, чье значение хэш-функции, чтобы вычислить
    
    Возвраты:
    
    основанный на контенте хэш-код для a
    
    С тех пор:
    
    1.5
  - хэш-код
```
public static int hashCode(double[] a)
```
    Возвращает хэш-код, основанный на содержании указанного массива. Для любых двух массивов double a и b так, что Arrays.equals(a, b), это также имеет место тот Arrays.hashCode(a) == Arrays.hashCode(b).
    Значение, возвращенное этим методом, является тем же самым значением, которое было бы получено, вызывая hashCode метод на a List содержа последовательность Double экземпляры, представляющие элементы a в том же самом порядке. Если a является null, этот метод возвращается 0.
    
    Параметры:
    
    a - массив, чье значение хэш-функции, чтобы вычислить
    
    Возвраты:
    
    основанный на контенте хэш-код для a
    
    С тех пор:
    
    1.5
  - хэш-код
```
public static int hashCode(Object[] a)
```
    Возвращает хэш-код, основанный на содержании указанного массива. Если массив содержит другие массивы как элементы, хэш-код основан на их идентификационных данных, а не их содержании. Поэтому приемлемо вызвать этот метод на массив, который содержит себя как элемент, или прямо или косвенно через один или более уровней массивов.
    Для любых двух массивов a и b так, что Arrays.equals(a, b), это также имеет место тот Arrays.hashCode(a) == Arrays.hashCode(b).
    Значение, возвращенное этим методом, равно значению, которое было бы возвращено Arrays.asList(a).hashCode(), если a не является null, когда 0 возвращается.
    
    Параметры:
    
    a - массив, чей основанный на контенте хэш-код, чтобы вычислить
    
    Возвраты:
    
    основанный на контенте хэш-код для a
    
    С тех пор:
    
    1.5
    
    См. Также:
    
    deepHashCode(Object[])
  - deepHashCode
```
public static int deepHashCode(Object[] a)
```
    Возвращает хэш-код, основанный на "глубоком содержании" указанного массива. Если массив содержит другие массивы как элементы, хэш-код основан на их содержании и так далее, до бесконечности. Поэтому недопустимо вызвать этот метод на массив, который содержит себя как элемент, или прямо или косвенно через один или более уровней массивов. Поведение такого вызова неопределено.
    Для любых двух массивов a и b так, что Arrays.deepEquals(a, b), это также имеет место тот Arrays.deepHashCode(a) == Arrays.deepHashCode(b).
    Вычисление значения, возвращенного этим методом, подобно тому из значения, возвращенного List.hashCode() в списке, содержащем те же самые элементы как a в том же самом порядке, с одним различием: Если элемент, e a является самостоятельно массивом, его хэш-код, вычисляется не, вызывая e.hashCode(), но как, вызывая соответствующую перегрузку Arrays.hashCode(e), если e является массивом типа примитива, или как, вызывая Arrays.deepHashCode(e) рекурсивно, если e является массивом ссылочного типа. Если a является null, этот метод возвращается 0.
    
    Параметры:
    
    a - массив, чей глубокий контент базируемый хэш-код, чтобы вычислить
    
    Возвраты:
    
    глубокий контент базируемый хэш-код для a
    
    С тех пор:
    
    1.5
    
    См. Также:
    
    hashCode(Object[])
  - deepEquals
```
public static boolean deepEquals(Object[] a1,
                                 Object[] a2)
```
    true возвратов, если два указанных массива очень равны друг другу. В отличие от этого equals(Object[],Object[]) метод, этот метод является подходящим для использования с вложенными массивами произвольной глубины.
    Две ссылки массива считают очень равными, если и null, или если они обращаются к массивам, которые содержат то же самое число элементов и всех соответствующих пар элементов в двух массивах, глубоко равны.
    Два возможно элементы null e1 и e2 очень равны, если какое-либо из следующих условий содержит:
    - e1 и e2 являются оба массивами типов ссылки на объект, и Arrays.deepEquals(e1, e2) would return true
    - e1 и e2 являются массивами того же самого типа примитива, и соответствующая перегрузка Arrays.equals(e1, e2) возвратила бы true.
    - e1 == e2
    - e1.equals(e2) возвратил бы true.
    Отметьте, что это определение разрешает элементы null в любой глубине.
    Если любой из указанных массивов содержит себя как элементы или прямо или косвенно через один или более уровней массивов, поведение этого метода неопределено.
    Параметры:
    
    a1 - один массив, который будет протестирован на равенство
    
    a2 - другой массив, который будет протестирован на равенство
    
    Возвраты:
    
    true, если два массива равны
    
    С тех пор:
    
    1.5
    
    См. Также:
    
    equals(Object[],Object[]), Objects.deepEquals(Object, Object)
  - toString
```
public static String toString(long[] a)
```
    Возвращает строковое представление содержания указанного массива. Строковое представление состоит из списка элементов массива, включенных в квадратные скобки ("[]"). Смежные элементы разделяются символами ", " (запятая, сопровождаемая пространством). Элементы преобразовываются в строки как String.valueOf(long). "null" возвратов, если a является null.
    
    Параметры:
    
    a - массив, чье строковое представление возврату
    
    Возвраты:
    
    строковое представление a
    
    С тех пор:
    
    1.5
  - toString
```
public static String toString(int[] a)
```
    Возвращает строковое представление содержания указанного массива. Строковое представление состоит из списка элементов массива, включенных в квадратные скобки ("[]"). Смежные элементы разделяются символами ", " (запятая, сопровождаемая пространством). Элементы преобразовываются в строки как String.valueOf(int). "null" возвратов, если a является null.
    
    Параметры:
    
    a - массив, чье строковое представление возврату
    
    Возвраты:
    
    строковое представление a
    
    С тех пор:
    
    1.5
  - toString
```
public static String toString(short[] a)
```
    Возвращает строковое представление содержания указанного массива. Строковое представление состоит из списка элементов массива, включенных в квадратные скобки ("[]"). Смежные элементы разделяются символами ", " (запятая, сопровождаемая пространством). Элементы преобразовываются в строки как String.valueOf(short). "null" возвратов, если a является null.
    
    Параметры:
    
    a - массив, чье строковое представление возврату
    
    Возвраты:
    
    строковое представление a
    
    С тех пор:
    
    1.5
  - toString
```
public static String toString(char[] a)
```
    Возвращает строковое представление содержания указанного массива. Строковое представление состоит из списка элементов массива, включенных в квадратные скобки ("[]"). Смежные элементы разделяются символами ", " (запятая, сопровождаемая пространством). Элементы преобразовываются в строки как String.valueOf(char). "null" возвратов, если a является null.
    
    Параметры:
    
    a - массив, чье строковое представление возврату
    
    Возвраты:
    
    строковое представление a
    
    С тех пор:
    
    1.5
  - toString
```
public static String toString(byte[] a)
```
    Возвращает строковое представление содержания указанного массива. Строковое представление состоит из списка элементов массива, включенных в квадратные скобки ("[]"). Смежные элементы разделяются символами ", " (запятая, сопровождаемая пространством). Элементы преобразовываются в строки как String.valueOf(byte). "null" возвратов, если a является null.
    
    Параметры:
    
    a - массив, чье строковое представление возврату
    
    Возвраты:
    
    строковое представление a
    
    С тех пор:
    
    1.5
  - toString
```
public static String toString(boolean[] a)
```
    Возвращает строковое представление содержания указанного массива. Строковое представление состоит из списка элементов массива, включенных в квадратные скобки ("[]"). Смежные элементы разделяются символами ", " (запятая, сопровождаемая пространством). Элементы преобразовываются в строки как String.valueOf(boolean). "null" возвратов, если a является null.
    
    Параметры:
    
    a - массив, чье строковое представление возврату
    
    Возвраты:
    
    строковое представление a
    
    С тех пор:
    
    1.5
  - toString
```
public static String toString(float[] a)
```
    Возвращает строковое представление содержания указанного массива. Строковое представление состоит из списка элементов массива, включенных в квадратные скобки ("[]"). Смежные элементы разделяются символами ", " (запятая, сопровождаемая пространством). Элементы преобразовываются в строки как String.valueOf(float). "null" возвратов, если a является null.
    
    Параметры:
    
    a - массив, чье строковое представление возврату
    
    Возвраты:
    
    строковое представление a
    
    С тех пор:
    
    1.5
  - toString
```
public static String toString(double[] a)
```
    Возвращает строковое представление содержания указанного массива. Строковое представление состоит из списка элементов массива, включенных в квадратные скобки ("[]"). Смежные элементы разделяются символами ", " (запятая, сопровождаемая пространством). Элементы преобразовываются в строки как String.valueOf(double). "null" возвратов, если a является null.
    
    Параметры:
    
    a - массив, чье строковое представление возврату
    
    Возвраты:
    
    строковое представление a
    
    С тех пор:
    
    1.5
  - toString
```
public static String toString(Object[] a)
```
    Возвращает строковое представление содержания указанного массива. Если массив содержит другие массивы как элементы, они преобразовываются в строки Object.toString() метод, наследованный от Object, который описывает их идентификационные данные, а не их содержание.
    Значение, возвращенное этим методом, равно значению, которое было бы возвращено Arrays.asList(a).toString(), если a не является null, когда "null" возвращается.
    
    Параметры:
    
    a - массив, чье строковое представление возврату
    
    Возвраты:
    
    строковое представление a
    
    С тех пор:
    
    1.5
    
    См. Также:
    
    deepToString(Object[])
  - deepToString
```
public static String deepToString(Object[] a)
```
    Возвращает строковое представление "глубокого содержания" указанного массива. Если массив содержит другие массивы как элементы, строковое представление содержит их содержание и так далее. Этот метод разрабатывается для того, чтобы преобразовать многомерные массивы в строки.
    Строковое представление состоит из списка элементов массива, включенных в квадратные скобки ("[]"). Смежные элементы разделяются символами ", " (запятая, сопровождаемая пространством). Элементы преобразовываются в строки как String.valueOf(Object), если они не самостоятельно массивы.
    Если элемент, e является массивом типа примитива, он преобразовывается в строку как, вызывая соответствующую перегрузку Arrays.toString(e). Если элемент, e является массивом ссылочного типа, он преобразовывается в строку как, вызывая этот метод рекурсивно.
    Чтобы избежать бесконечной рекурсии, если указанный массив содержит себя как элемент, или содержит косвенную ссылку на себя через один или более уровней массивов, самоссылка преобразовывается в строку "[...]". Например, массив, содержащий только ссылку на себя, был бы представлен как "[[...]]".
    Этот метод возвращает "null", если указанным массивом является null.
    
    Параметры:
    
    a - массив, чье строковое представление возврату
    
    Возвраты:
    
    строковое представление a
    
    С тех пор:
    
    1.5
    
    См. Также:
    
    toString(Object[])
  - setAll
```
public static <T> void setAll(T[] array,
                              IntFunction<? extends T> generator)
```
    Установите все элементы указанного массива, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
    Если функция генератора выдает исключение, она передается к вызывающей стороне, и массив оставляют в неопределенном состоянии.
    
    Введите Параметры:
    
    T - тип элементов массива
    
    Параметры:
    
    array - массив, который будет инициализирован
    
    generator - функция, принимающая индексирование и производящая требуемое значение для той позиции
    
    Броски:
    
    NullPointerException - если генератор является нулем
    
    С тех пор:
    
    1.8
  - parallelSetAll
```
public static <T> void parallelSetAll(T[] array,
                                      IntFunction<? extends T> generator)
```
    Установите все элементы указанного массива, параллельно, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
    Если функция генератора выдает исключение, исключение непроверенное выдается от parallelSetAll и массив оставляют в неопределенном состоянии.
    
    Введите Параметры:
    
    T - тип элементов массива
    
    Параметры:
    
    array - массив, который будет инициализирован
    
    generator - функция, принимающая индексирование и производящая требуемое значение для той позиции
    
    Броски:
    
    NullPointerException - если генератор является нулем
    
    С тех пор:
    
    1.8
  - setAll
```
public static void setAll(int[] array,
                          IntUnaryOperator generator)
```
    Установите все элементы указанного массива, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
    Если функция генератора выдает исключение, она передается к вызывающей стороне, и массив оставляют в неопределенном состоянии.
    
    Параметры:
    
    array - массив, который будет инициализирован
    
    generator - функция, принимающая индексирование и производящая требуемое значение для той позиции
    
    Броски:
    
    NullPointerException - если генератор является нулем
    
    С тех пор:
    
    1.8
  - parallelSetAll
```
public static void parallelSetAll(int[] array,
                                  IntUnaryOperator generator)
```
    Установите все элементы указанного массива, параллельно, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
    Если функция генератора выдает исключение, исключение непроверенное выдается от parallelSetAll и массив оставляют в неопределенном состоянии.
    
    Параметры:
    
    array - массив, который будет инициализирован
    
    generator - функция, принимающая индексирование и производящая требуемое значение для той позиции
    
    Броски:
    
    NullPointerException - если генератор является нулем
    
    С тех пор:
    
    1.8
  - setAll
```
public static void setAll(long[] array,
                          IntToLongFunction generator)
```
    Установите все элементы указанного массива, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
    Если функция генератора выдает исключение, она передается к вызывающей стороне, и массив оставляют в неопределенном состоянии.
    
    Параметры:
    
    array - массив, который будет инициализирован
    
    generator - функция, принимающая индексирование и производящая требуемое значение для той позиции
    
    Броски:
    
    NullPointerException - если генератор является нулем
    
    С тех пор:
    
    1.8
  - parallelSetAll
```
public static void parallelSetAll(long[] array,
                                  IntToLongFunction generator)
```
    Установите все элементы указанного массива, параллельно, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
    Если функция генератора выдает исключение, исключение непроверенное выдается от parallelSetAll и массив оставляют в неопределенном состоянии.
    
    Параметры:
    
    array - массив, который будет инициализирован
    
    generator - функция, принимающая индексирование и производящая требуемое значение для той позиции
    
    Броски:
    
    NullPointerException - если генератор является нулем
    
    С тех пор:
    
    1.8
  - setAll
```
public static void setAll(double[] array,
                          IntToDoubleFunction generator)
```
    Установите все элементы указанного массива, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
    Если функция генератора выдает исключение, она передается к вызывающей стороне, и массив оставляют в неопределенном состоянии.
    
    Параметры:
    
    array - массив, который будет инициализирован
    
    generator - функция, принимающая индексирование и производящая требуемое значение для той позиции
    
    Броски:
    
    NullPointerException - если генератор является нулем
    
    С тех пор:
    
    1.8
  - parallelSetAll
```
public static void parallelSetAll(double[] array,
                                  IntToDoubleFunction generator)
```
    Установите все элементы указанного массива, параллельно, используя обеспеченную функцию генератора, чтобы вычислить каждый элемент.
    Если функция генератора выдает исключение, исключение непроверенное выдается от parallelSetAll и массив оставляют в неопределенном состоянии.
    
    Параметры:
    
    array - массив, который будет инициализирован
    
    generator - функция, принимающая индексирование и производящая требуемое значение для той позиции
    
    Броски:
    
    NullPointerException - если генератор является нулем
    
    С тех пор:
    
    1.8
  - spliterator
```
public static <T> Spliterator<T> spliterator(T[] array)
```
    Возвраты a Spliterator покрытие всего указанного массива.
    Отчеты spliterator Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED, и Spliterator.IMMUTABLE.
    
    Введите Параметры:
    
    T - тип элементов
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    Возвраты:
    
    spliterator для элементов массива
    
    С тех пор:
    
    1.8
  - spliterator
```
public static <T> Spliterator<T> spliterator(T[] array,
                                             int startInclusive,
                                             int endExclusive)
```
    Возвраты a Spliterator покрытие указанного диапазона указанного массива.
    Отчеты spliterator Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED, и Spliterator.IMMUTABLE.
    
    Введите Параметры:
    
    T - тип элементов
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    startInclusive - первые индексируют, чтобы покрыть, включительно
    
    endExclusive - индексируйте сразу мимо последнего, индексируют, чтобы покрыть
    
    Возвраты:
    
    spliterator для элементов массива
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше чем startInclusive, или endExclusive больше чем размер массива
    
    С тех пор:
    
    1.8
  - spliterator
```
public static Spliterator.OfInt spliterator(int[] array)
```
    Возвраты a Spliterator.OfInt покрытие всего указанного массива.
    Отчеты spliterator Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED, и Spliterator.IMMUTABLE.
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    Возвраты:
    
    spliterator для элементов массива
    
    С тех пор:
    
    1.8
  - spliterator
```
public static Spliterator.OfInt spliterator(int[] array,
                                            int startInclusive,
                                            int endExclusive)
```
    Возвраты a Spliterator.OfInt покрытие указанного диапазона указанного массива.
    Отчеты spliterator Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED, и Spliterator.IMMUTABLE.
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    startInclusive - первые индексируют, чтобы покрыть, включительно
    
    endExclusive - индексируйте сразу мимо последнего, индексируют, чтобы покрыть
    
    Возвраты:
    
    spliterator для элементов массива
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше чем startInclusive, или endExclusive больше чем размер массива
    
    С тех пор:
    
    1.8
  - spliterator
```
public static Spliterator.OfLong spliterator(long[] array)
```
    Возвраты a Spliterator.OfLong покрытие всего указанного массива.
    Отчеты spliterator Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED, и Spliterator.IMMUTABLE.
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    Возвраты:
    
    spliterator для элементов массива
    
    С тех пор:
    
    1.8
  - spliterator
```
public static Spliterator.OfLong spliterator(long[] array,
                                             int startInclusive,
                                             int endExclusive)
```
    Возвраты a Spliterator.OfLong покрытие указанного диапазона указанного массива.
    Отчеты spliterator Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED, и Spliterator.IMMUTABLE.
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    startInclusive - первые индексируют, чтобы покрыть, включительно
    
    endExclusive - индексируйте сразу мимо последнего, индексируют, чтобы покрыть
    
    Возвраты:
    
    spliterator для элементов массива
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше чем startInclusive, или endExclusive больше чем размер массива
    
    С тех пор:
    
    1.8
  - spliterator
```
public static Spliterator.OfDouble spliterator(double[] array)
```
    Возвраты a Spliterator.OfDouble покрытие всего указанного массива.
    Отчеты spliterator Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED, и Spliterator.IMMUTABLE.
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    Возвраты:
    
    spliterator для элементов массива
    
    С тех пор:
    
    1.8
  - spliterator
```
public static Spliterator.OfDouble spliterator(double[] array,
                                               int startInclusive,
                                               int endExclusive)
```
    Возвраты a Spliterator.OfDouble покрытие указанного диапазона указанного массива.
    Отчеты spliterator Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED, и Spliterator.IMMUTABLE.
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    startInclusive - первые индексируют, чтобы покрыть, включительно
    
    endExclusive - индексируйте сразу мимо последнего, индексируют, чтобы покрыть
    
    Возвраты:
    
    spliterator для элементов массива
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше чем startInclusive, или endExclusive больше чем размер массива
    
    С тех пор:
    
    1.8
  - поток
```
public static <T> Stream<T> stream(T[] array)
```
    Возвращает последовательное Stream с указанным массивом как его источник.
    
    Введите Параметры:
    
    T - Тип элементов массива
    
    Параметры:
    
    array - Массив, который, как предполагают, был неизменен во время использования
    
    Возвраты:
    
    a Stream для массива
    
    С тех пор:
    
    1.8
  - поток
```
public static <T> Stream<T> stream(T[] array,
                                   int startInclusive,
                                   int endExclusive)
```
    Возвращает последовательное Stream с указанным диапазоном указанного массива как его источник.
    
    Введите Параметры:
    
    T - тип элементов массива
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    startInclusive - первые индексируют, чтобы покрыть, включительно
    
    endExclusive - индексируйте сразу мимо последнего, индексируют, чтобы покрыть
    
    Возвраты:
    
    a Stream для диапазона массива
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше чем startInclusive, или endExclusive больше чем размер массива
    
    С тех пор:
    
    1.8
  - поток
```
public static IntStream stream(int[] array)
```
    Возвращает последовательное IntStream с указанным массивом как его источник.
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    Возвраты:
    
    IntStream для массива
    
    С тех пор:
    
    1.8
  - поток
```
public static IntStream stream(int[] array,
                               int startInclusive,
                               int endExclusive)
```
    Возвращает последовательное IntStream с указанным диапазоном указанного массива как его источник.
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    startInclusive - первые индексируют, чтобы покрыть, включительно
    
    endExclusive - индексируйте сразу мимо последнего, индексируют, чтобы покрыть
    
    Возвраты:
    
    IntStream для диапазона массива
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше чем startInclusive, или endExclusive больше чем размер массива
    
    С тех пор:
    
    1.8
  - поток
```
public static LongStream stream(long[] array)
```
    Возвращает последовательное LongStream с указанным массивом как его источник.
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    Возвраты:
    
    a LongStream для массива
    
    С тех пор:
    
    1.8
  - поток
```
public static LongStream stream(long[] array,
                                int startInclusive,
                                int endExclusive)
```
    Возвращает последовательное LongStream с указанным диапазоном указанного массива как его источник.
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    startInclusive - первые индексируют, чтобы покрыть, включительно
    
    endExclusive - индексируйте сразу мимо последнего, индексируют, чтобы покрыть
    
    Возвраты:
    
    a LongStream для диапазона массива
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше чем startInclusive, или endExclusive больше чем размер массива
    
    С тех пор:
    
    1.8
  - поток
```
public static DoubleStream stream(double[] array)
```
    Возвращает последовательное DoubleStream с указанным массивом как его источник.
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    Возвраты:
    
    a DoubleStream для массива
    
    С тех пор:
    
    1.8
  - поток
```
public static DoubleStream stream(double[] array,
                                  int startInclusive,
                                  int endExclusive)
```
    Возвращает последовательное DoubleStream с указанным диапазоном указанного массива как его источник.
    
    Параметры:
    
    array - массив, который, как предполагают, был неизменен во время использования
    
    startInclusive - первые индексируют, чтобы покрыть, включительно
    
    endExclusive - индексируйте сразу мимо последнего, индексируют, чтобы покрыть
    
    Возвраты:
    
    a DoubleStream для диапазона массива
    
    Броски:
    
    ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше чем startInclusive, или endExclusive больше чем размер массива
    
    С тех пор:
    
    1.8

Представьте ошибку или функцию
Для дальнейшей ссылки API и документации разработчика, см. Java Документация SE. Та документация содержит более подробные, предназначенные разработчиком описания, с концептуальными краткими обзорами, определениями сроков, обходных решений, и рабочих примеров кода.
Авторское право © 1993, 2013, Oracle и/или его филиалы. Все права защищены.
Проект сборка-b92

Массивы класса

Сводка метода

Методы, наследованные от class java.lang. Объект

Деталь метода

вид

вид

вид

вид

вид

вид

вид

вид

вид

вид

вид

вид

вид

вид

вид

вид

вид

вид

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

parallelSort

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

binarySearch

равняется

равняется

равняется

равняется

равняется

равняется

равняется

равняется

равняется

заливка

заливка

заливка

заливка

заливка

заливка

заливка

заливка

заливка

заливка

заливка

заливка

заливка