Класс Arrays

java.lang.Object
- java.util.Arrays

public class Arrays
extends Object

В этом классе содержатся различные методы для работы с массивами (такие как сортировка и поиск). Этот класс также содержит статический фабричный метод, позволяющий рассматривать массивы как списки.

Все методы этого класса выбрасывают исключение NullPointerException, если указанная ссылка на массив равна null, если не указано иное.

Документация для методов, содержащихся в этом классе, включает краткие описания реализаций. Такие описания следует рассматривать как примечания к реализации, а не как части спецификации. Реализаторы могут свободно заменять другие алгоритмы, при условии, что сама спецификация соблюдается. (Например, алгоритм, используемый sort(Object[]) не обязательно должен быть MergeSort, но он должен быть стабильным.)

Этот класс является членом Фреймворка Java Collections.

Since:: 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)`	Ищет указанное значение в указанном массиве целых чисел, используя алгоритм двоичного поиска.
`static int`	`binarySearch(int[] a, int fromIndex, int toIndex, int key)`	Ищет указанное значение в диапазоне указанного массива целых чисел, используя алгоритм двоичного поиска.
`static int`	`binarySearch(long[] a, int fromIndex, int toIndex, long key)`	Ищет указанное значение в диапазоне указанного массива длинных целых чисел, используя алгоритм двоичного поиска.
`static int`	`binarySearch(long[] a, long key)`	Ищет указанное значение в указанном массиве длинных целых чисел, используя алгоритм двоичного поиска.
`static int`	`binarySearch(short[] a, int fromIndex, int toIndex, short key)`	Ищет указанное значение в диапазоне указанного массива коротких целых чисел, используя алгоритм двоичного поиска.
`static int`	`binarySearch(short[] a, short key)`	Ищет указанное значение в указанном массиве коротких целых чисел, используя алгоритм двоичного поиска.
`static int`	`binarySearch(Object[] a, int fromIndex, int toIndex, Object key)`	Ищет указанный объект в диапазоне указанного массива, используя алгоритм двоичного поиска.
`static int`	`binarySearch(Object[] a, Object 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 int`	`compare(boolean[] a, boolean[] b)`	Сравнивает два массива `boolean` лексикографически.
`static int`	`compare(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `boolean` лексикографически в указанных диапазонах.
`static int`	`compare(byte[] a, byte[] b)`	Сравнивает два массива `byte` лексикографически.
`static int`	`compare(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `byte` лексикографически в указанных диапазонах.
`static int`	`compare(char[] a, char[] b)`	Сравнивает два массива `char` лексикографически.
`static int`	`compare(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `char` лексикографически в указанных диапазонах.
`static int`	`compare(double[] a, double[] b)`	Сравнивает два массива `double` лексикографически.
`static int`	`compare(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `double` лексикографически в указанных диапазонах.
`static int`	`compare(float[] a, float[] b)`	Сравнивает два массива `float` лексикографически.
`static int`	`compare(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `float` лексикографически в указанных диапазонах.
`static int`	`compare(int[] a, int[] b)`	Сравнивает два массива `int` лексикографически.
`static int`	`compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `int` лексикографически в указанных диапазонах.
`static int`	`compare(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `long` лексикографически в указанных диапазонах.
`static int`	`compare(long[] a, long[] b)`	Сравнивает два массива `long` лексикографически.
`static int`	`compare(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `short` лексикографически в указанных диапазонах.
`static int`	`compare(short[] a, short[] b)`	Сравнивает два массива `short` лексикографически.
`static <T extends Comparable<? super T>> int`	`compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `Object` лексикографически в указанных диапазонах.
`static <T> int`	`compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)`	Сравнивает два массива `Object` лексикографически в указанных диапазонах.
`static <T extends Comparable<? super T>> int`	`compare(T[] a, T[] b)`	Сравнивает два массива `Object` лексикографически, внутри сравнимых элементов.
`static <T> int`	`compare(T[] a, T[] b, Comparator<? super T> cmp)`	Сравнивает два массива `Object` лексикографически, используя указанный компаратор.
`static int`	`compareUnsigned(byte[] a, byte[] b)`	Сравнивает два массива `byte` лексикографически, численно обрабатывая элементы как беззнаковые.
`static int`	`compareUnsigned(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `byte` лексикографически в указанных диапазонах, численно обрабатывая элементы как беззнаковые.
`static int`	`compareUnsigned(int[] a, int[] b)`	Сравнивает два массива `int` лексикографически, численно обрабатывая элементы как беззнаковые.
`static int`	`compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `int` лексикографически в указанных диапазонах, численно обрабатывая элементы как беззнаковые.
`static int`	`compareUnsigned(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `long` лексикографически в указанных диапазонах, численно обрабатывая элементы как беззнаковые.
`static int`	`compareUnsigned(long[] a, long[] b)`	Сравнивает два массива `long` лексикографически, численно обрабатывая элементы как беззнаковые.
`static int`	`compareUnsigned(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	Сравнивает два массива `short` лексикографически в указанных диапазонах, численно обрабатывая элементы как беззнаковые.
`static int`	`compareUnsigned(short[] a, short[] b)`	Сравнивает два массива `short` лексикографически, численно обрабатывая элементы как беззнаковые.
`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)`	Копирует указанный массив, усекая или заполняя значениями null (при необходимости), чтобы копия имела указанную длину.
`static <T,U> T[]`	`copyOf(U[] original, int newLength, Class<? extends T[]> newType)`	Копирует указанный массив, усекая или заполняя значениями null (при необходимости), чтобы копия имела указанную длину.
`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(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)`	Возвращает true, если два указанных массива булевых значений в указанных диапазонах равны друг другу.
`static boolean`	`equals(byte[] a, byte[] a2)`	Возвращает `true`, если два указанных массива байтов равны друг другу.
`static boolean`	`equals(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)`	Возвращает true, если два указанных массива байтов в указанных диапазонах равны друг другу.
`static boolean`	`equals(char[] a, char[] a2)`	Возвращает `true`, если два указанных массива символов равны друг другу.
`static boolean`	`equals(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)`	Возвращает true, если два указанных массива символов в указанных диапазонах равны друг другу.
`static boolean`	`equals(double[] a, double[] a2)`	Возвращает `true`, если два указанных массива двойных чисел равны друг другу.
`static boolean`	`equals(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)`	Возвращает true, если два указанных массива двойных чисел в указанных диапазонах равны друг другу.
`static boolean`	`equals(float[] a, float[] a2)`	Возвращает `true`, если два указанных массива чисел с плавающей точкой равны друг другу.
`static boolean`	`equals(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)`	Возвращает true, если два указанных массива чисел с плавающей точкой в указанных диапазонах равны друг другу.
`static boolean`	`equals(int[] a, int[] a2)`	Возвращает `true`, если два указанных массива целых чисел равны друг другу.
`static boolean`	`equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)`	Возвращает true, если два указанных массива целых чисел в указанных диапазонах равны друг другу.
`static boolean`	`equals(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)`	Возвращает true, если два указанных массива длинных целых чисел в указанных диапазонах равны друг другу.
`static boolean`	`equals(long[] a, long[] a2)`	Возвращает `true`, если два указанных массива длинных целых чисел равны друг другу.
`static boolean`	`equals(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	Возвращает true, если два указанных массива коротких целых чисел в указанных диапазонах равны друг другу.
`static boolean`	`equals(short[] a, short[] a2)`	Возвращает `true`, если два указанных массива коротких целых чисел равны друг другу.
`static boolean`	`equals(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)`	Возвращает true, если два указанных массива объектов в указанных диапазонах равны друг другу.
`static boolean`	`equals(Object[] a, Object[] a2)`	Возвращает `true`, если два указанных массива объектов равны друг другу.
`static <T> boolean`	`equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)`	Возвращает true, если два указанных массива объектов в указанных диапазонах равны друг другу.
`static <T> boolean`	`equals(T[] a, T[] a2, Comparator<? super T> cmp)`	Возвращает `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)`	Присваивает указанное целое значение каждому элементу указанного массива целых чисел.
`static void`	`fill(int[] a, int fromIndex, int toIndex, int val)`	Присваивает указанное целое значение каждому элементу указанного диапазона указанного массива целых чисел.
`static void`	`fill(long[] a, int fromIndex, int toIndex, long val)`	Присваивает указанное значение длинного целого типа каждому элементу указанного диапазона указанного массива длинных целых чисел.
`static void`	`fill(long[] a, long val)`	Присваивает указанное значение длинного целого типа каждому элементу указанного массива длинных целых чисел.
`static void`	`fill(short[] a, int fromIndex, int toIndex, short val)`	Присваивает указанное значение короткого целого типа каждому элементу указанного диапазона указанного массива коротких целых чисел.
`static void`	`fill(short[] a, short val)`	Присваивает указанное значение короткого целого типа каждому элементу указанного массива коротких целых чисел.
`static void`	`fill(Object[] a, int fromIndex, int toIndex, Object val)`	Присваивает указанную ссылку на объект каждому элементу указанного диапазона указанного массива объектов.
`static void`	`fill(Object[] a, Object 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(short[] a)`	Возвращает хэш-код на основе содержимого указанного массива.
`static int`	`hashCode(Object[] a)`	Возвращает хэш-код на основе содержимого указанного массива.
`static int`	`mismatch(boolean[] a, boolean[] b)`	Находит и возвращает индекс первого несовпадения между двумя `boolean` массивами, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(boolean[] a, int aFromIndex, int aToIndex, boolean[] b, int bFromIndex, int bToIndex)`	Находит и возвращает относительный индекс первого несовпадения между двумя `boolean` массивами в указанных диапазонах, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(byte[] a, byte[] b)`	Находит и возвращает индекс первого несовпадения между двумя `byte` массивами, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex)`	Находит и возвращает относительный индекс первого несовпадения между двумя `byte` массивами в указанных диапазонах, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(char[] a, char[] b)`	Находит и возвращает индекс первого несовпадения между двумя `char` массивами, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex)`	Находит и возвращает относительный индекс первого несовпадения между двумя `char` массивами в указанных диапазонах, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(double[] a, double[] b)`	Находит и возвращает индекс первого несовпадения между двумя `double` массивами, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex)`	Находит и возвращает относительный индекс первого несовпадения между двумя `double` массивами в указанных диапазонах, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(float[] a, float[] b)`	Находит и возвращает индекс первого несовпадения между двумя `float` массивами, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex)`	Находит и возвращает относительный индекс первого несовпадения между двумя `float` массивами в указанных диапазонах, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(int[] a, int[] b)`	Находит и возвращает индекс первого несовпадения между двумя `int` массивами, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)`	Находит и возвращает относительный индекс первого несовпадения между двумя `int` массивами в указанных диапазонах, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex)`	Находит и возвращает относительный индекс первого несовпадения между двумя `long` массивами в указанных диапазонах, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(long[] a, long[] b)`	Находит и возвращает индекс первого несовпадения между двумя `long` массивами, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex)`	Находит и возвращает относительный индекс первого несовпадения между двумя `short` массивами в указанных диапазонах, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(short[] a, short[] b)`	Находит и возвращает индекс первого несовпадения между двумя `short` массивами, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(Object[] a, int aFromIndex, int aToIndex, Object[] b, int bFromIndex, int bToIndex)`	Находит и возвращает относительный индекс первого несовпадения между двумя `Object` массивами в указанных диапазонах, в противном случае возвращает -1, если несовпадений не найдено.
`static int`	`mismatch(Object[] a, Object[] b)`	Находит и возвращает индекс первого несовпадения между двумя `Object` массивами, в противном случае возвращает -1, если несовпадений не найдено.
`static <T> int`	`mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)`	Находит и возвращает относительный индекс первого несовпадения между двумя `Object` массивами в указанных диапазонах, в противном случае возвращает -1, если несовпадений не найдено.
`static <T> int`	`mismatch(T[] a, T[] b, Comparator<? super T> cmp)`	Находит и возвращает индекс первого несовпадения между двумя `Object` массивами, в противном случае возвращает -1, если несовпадений не найдено.
`static void`	`parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)`	Выполняет `parallelPrefix(double[], DoubleBinaryOperator)` для заданного поддиапазона массива.
`static void`	`parallelPrefix(double[] array, DoubleBinaryOperator op)`	Параллельно накапливает каждый элемент данного массива на месте, используя предоставленную функцию.
`static void`	`parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)`	Выполняет `parallelPrefix(int[], IntBinaryOperator)` для заданного поддиапазона массива.
`static void`	`parallelPrefix(int[] array, IntBinaryOperator op)`	Параллельно накапливает каждый элемент данного массива на месте, используя предоставленную функцию.
`static void`	`parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)`	Выполняет `parallelPrefix(long[], LongBinaryOperator)` для заданного поддиапазона массива.
`static void`	`parallelPrefix(long[] array, LongBinaryOperator op)`	Параллельно накапливает каждый элемент данного массива на месте, используя предоставленную функцию.
`static <T> void`	`parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator<T> op)`	Выполняет `parallelPrefix(Object[], BinaryOperator)` для заданного поддиапазона массива.
`static <T> void`	`parallelPrefix(T[] array, BinaryOperator<T> op)`	Параллельно накапливает каждый элемент данного массива на месте, используя предоставленную функцию.
`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 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> cmp)`	Сортирует указанный диапазон указанного массива объектов согласно порядку, заданному указанным компаратором.
`static <T> void`	`parallelSort(T[] a, Comparator<? super T> cmp)`	Сортирует указанный массив объектов согласно порядку, заданному указанным компаратором.
`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(short[] a)`	Сортирует указанный массив в порядке возрастания числовых значений.
`static void`	`sort(short[] a, int fromIndex, int toIndex)`	Сортирует указанный диапазон массива в порядке возрастания.
`static void`	`sort(Object[] a)`	Сортирует указанный массив объектов в порядке возрастания, согласно естественному порядку его элементов.
`static void`	`sort(Object[] a, int fromIndex, int toIndex)`	Сортирует указанный диапазон указанного массива объектов в порядке возрастания, согласно естественному порядку его элементов.
`static <T> void`	`sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)`	Сортирует указанный диапазон указанного массива объектов согласно порядку, заданному указанным компаратором.
`static <T> void`	`sort(T[] a, Comparator<? super T> c)`	Сортирует указанный массив объектов согласно порядку, заданному указанным компаратором.
`static Spliterator.OfDouble`	`spliterator(double[] array)`	Возвращает `Spliterator.OfDouble` , охватывающий весь указанный массив.
`static Spliterator.OfDouble`	`spliterator(double[] array, int startInclusive, int endExclusive)`	Возвращает `Spliterator.OfDouble` , охватывающий указанный диапазон указанного массива.
`static Spliterator.OfInt`	`spliterator(int[] array)`	Возвращает `Spliterator.OfInt` , охватывающий весь указанный массив.
`static Spliterator.OfInt`	`spliterator(int[] array, int startInclusive, int endExclusive)`	Возвращает `Spliterator.OfInt` , охватывающий указанный диапазон указанного массива.
`static Spliterator.OfLong`	`spliterator(long[] array)`	Возвращает `Spliterator.OfLong` , охватывающий весь указанный массив.
`static Spliterator.OfLong`	`spliterator(long[] array, int startInclusive, int endExclusive)`	Возвращает `Spliterator.OfLong` , охватывающий указанный диапазон указанного массива.
`static <T> Spliterator<T>`	`spliterator(T[] array)`	Возвращает `Spliterator` , охватывающий весь указанный массив.
`static <T> Spliterator<T>`	`spliterator(T[] array, int startInclusive, int endExclusive)`	Возвращает `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(short[] a)`	Возвращает строковое представление содержимого указанного массива.
`static String`	`toString(Object[] a)`	Возвращает строковое представление содержимого указанного массива.

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

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

Краткое описание методов

sort

public static void sort(int[] a)

Сортирует указанный массив в порядке возрастания.

Примечание об имплементации: Алгоритм сортировки — это быстрая сортировка с двумя опорными элементами Владимира Ярославского, Джона Бентли и Джошуа Блоха. Этот алгоритм обеспечивает производительность O(n log(n)) во многих наборах данных, которые заставляют другие быстрые сортировки снижать производительность до квадратичной, и обычно быстрее, чем традиционные (с одним опорным элементом) реализации быстрой сортировки.

Параметры:: a - массив для сортировки

sort

public static void sort(int[] a,
                        int fromIndex,
                        int toIndex)

Сортирует указанный диапазон массива в порядке возрастания. Сортируемый диапазон простирается от индекса fromIndex, включительно, до индекса toIndex, не включительно. Если fromIndex == toIndex, сортируемый диапазон пуст.

Параметры:: a - массив для сортировки; fromIndex - индекс первого элемента, включительно, для сортировки; toIndex - индекс последнего элемента, не включительно, для сортировки
Исключения:: IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length

sort

public static void sort(long[] a)

Сортирует указанный массив в порядке возрастания.

Параметры:: a - массив для сортировки

sort

public static void sort(long[] a,
                        int fromIndex,
                        int toIndex)

Параметры:: a - массив для сортировки; fromIndex - индекс первого элемента, включительно, для сортировки; toIndex - индекс последнего элемента, не включительно, для сортировки
Исключения:: IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length

sort

public static void sort(short[] a)

Сортирует указанный массив в порядке возрастания.

Параметры:: a - массив для сортировки

sort

public static void sort(short[] a,
                        int fromIndex,
                        int toIndex)

Параметры:: a - массив для сортировки; fromIndex - индекс первого элемента, включительно, для сортировки; toIndex - индекс последнего элемента, не включительно, для сортировки
Исключения:: IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length

sort

public static void sort(char[] a)

Сортирует указанный массив в порядке возрастания.

Параметры:: a - массив для сортировки

sort

public static void sort(char[] a,
                        int fromIndex,
                        int toIndex)

Параметры:: a - массив для сортировки; fromIndex - индекс первого элемента, включительно, для сортировки; toIndex - индекс последнего элемента, не включительно, для сортировки
Исключения:: IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length

sort

public static void sort(byte[] a)

Сортирует указанный массив в порядке возрастания.

Параметры:: a - массив для сортировки

sort

public static void sort(byte[] a,
                        int fromIndex,
                        int toIndex)

Параметры:: a - массив для сортировки; fromIndex - индекс первого элемента, включительно, для сортировки; toIndex - индекс последнего элемента, не включительно, для сортировки
Исключения:: IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length

sort

public static void sort(float[] a)

Сортирует указанный массив в порядке возрастания.

Отношение < не обеспечивает полный порядок для всех значений с плавающей точкой: -0.0f == 0.0f является true и значение Float.NaN не сравнивается как меньше, больше или равно любому значению, даже самому себе. Этот метод использует полный порядок, навязанный методом Float.compareTo(java.lang.Float): -0.0f рассматривается как меньше, чем значение 0.0f и Float.NaN считается больше, чем любое другое значение, и все значения Float.NaN считаются равными.

Параметры:: a - массив для сортировки

sort

public static void sort(float[] a,
                        int fromIndex,
                        int toIndex)

Параметры:: a - массив для сортировки; fromIndex - индекс первого элемента, включительно, для сортировки; toIndex - индекс последнего элемента, не включительно, для сортировки
Исключения:: IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length

sort

public static void sort(double[] a)

Сортирует указанный массив в порядке возрастания.

Отношение < не обеспечивает полный порядок для всех значений double: -0.0d == 0.0d является true и значение Double.NaN не сравнивается как меньше, больше или равно любому значению, даже самому себе. Этот метод использует полный порядок, навязанный методом Double.compareTo(java.lang.Double): -0.0d рассматривается как меньше значения 0.0d, а Double.NaN считается больше любого другого значения, и все значения Double.NaN считаются равными.

Примечание об реализации: Алгоритм сортировки — это быстрая сортировка с двумя опорными элементами Владимира Ярославского, Джона Бентли и Джошуа Блоха. Этот алгоритм обеспечивает производительность O(n log(n)) во многих наборах данных, которые приводят к тому, что другие быстрые сортировки снижают производительность до квадратичной, и обычно быстрее, чем традиционные (с одним опорным элементом) реализации быстрой сортировки.

Параметры:: a - массив для сортировки

sort

public static void sort(double[] a,
                        int fromIndex,
                        int toIndex)

Сортирует указанный диапазон массива в порядке возрастания. Диапазон для сортировки простирается от индекса fromIndex, включительно, до индекса toIndex, не включительно. Если fromIndex == toIndex, диапазон для сортировки пуст.

Параметры:: a - массив для сортировки; fromIndex - индекс первого элемента, включительно, для сортировки; toIndex - индекс последнего элемента, не включительно, для сортировки
Исключения:: IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length

parallelSort

public static void parallelSort(byte[] a)

Сортирует указанный массив в порядке возрастания.

Примечание об реализации:: Алгоритм сортировки представляет собой параллельную сортировку-слияние, которая разбивает массив на подмассивы, которые сами сортируются, а затем сливаются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется с использованием соответствующего метода Arrays.sort. Если длина указанного массива меньше минимальной гранулярности, то он сортируется с использованием соответствующего метода Arrays.sort. Алгоритм требует рабочего пространства не большего, чем размер исходного массива. Для выполнения любых параллельных задач используется ForkJoin common pool.
Параметры:: a - массив для сортировки
С версии:: 1.8

parallelSort

public static void parallelSort(byte[] a,
                                int fromIndex,
                                int toIndex)

Примечание об реализации:: Алгоритм сортировки представляет собой параллельную сортировку-слияние, которая разбивает массив на подмассивы, которые сами сортируются, а затем сливаются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется с использованием соответствующего метода Arrays.sort. Если длина указанного массива меньше минимальной гранулярности, то он сортируется с использованием соответствующего метода 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. Если длина указанного массива меньше минимальной гранулярности, то он сортируется с использованием соответствующего метода Arrays.sort. Алгоритм требует рабочего пространства не большего, чем размер исходного массива. Для выполнения любых параллельных задач используется ForkJoin common pool.
Параметры:: a - массив для сортировки
С версии:: 1.8

parallelSort

public static void parallelSort(char[] a,
                                int fromIndex,
                                int toIndex)

Примечание об реализации:: Алгоритм сортировки представляет собой параллельную сортировку-слияние, которая разбивает массив на подмассивы, которые сами сортируются, а затем сливаются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется с использованием соответствующего метода Arrays.sort. Если длина указанного массива меньше минимальной гранулярности, то он сортируется с использованием соответствующего метода 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. Если длина указанного массива меньше минимальной гранулярности, то он сортируется с использованием соответствующего метода Arrays.sort. Алгоритм требует рабочего пространства не большего, чем размер исходного массива. Для выполнения любых параллельных задач используется ForkJoin common pool.
Параметры:: a - массив для сортировки
С версии:: 1.8

parallelSort

public static void parallelSort(short[] a,
                                int fromIndex,
                                int toIndex)

Примечание об реализации:: Алгоритм сортировки представляет собой параллельную сортировку-слияние, которая разбивает массив на подмассивы, которые сами сортируются, а затем сливаются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется с использованием соответствующего метода Arrays.sort. Если длина указанного массива меньше минимальной гранулярности, то он сортируется с использованием соответствующего метода 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. Если длина указанного массива меньше минимальной гранулярности, то он сортируется с использованием соответствующего метода 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. Если длина указанного массива меньше минимальной гранулярности, он сортируется с использованием соответствующего метода 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. Если длина указанного массива меньше минимальной гранулярности, он сортируется с использованием соответствующего метода Arrays.sort. Алгоритм требует рабочей области не большей, чем размер исходного массива. Для выполнения любых параллельных задач используется ForkJoin common pool.
Параметры:: a — массив, который необходимо отсортировать
С тех пор:: 1.8

parallelSort

public static void parallelSort(long[] a,
                                int fromIndex,
                                int toIndex)

Замечание по реализации:: Алгоритм сортировки — это параллельная сортировка-слияние, которая разбивает массив на подмассивы, которые сами по себе отсортированы, а затем сливаются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется с использованием соответствующего метода Arrays.sort. Если длина указанного массива меньше минимальной гранулярности, он сортируется с использованием соответствующего метода 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)

Сортирует указанный массив в порядке возрастания числовых значений.

Отношение < не обеспечивает полную упорядоченность для всех значений типа float: < является -0.0f == 0.0f и значение true не сравнивается ни меньше, ни больше, ни равно любому значению, даже самому себе. Этот метод использует полную упорядоченность, задаваемую методом Float.compareTo(java.lang.Float): -0.0f рассматривается как меньше значения 0.0f, а Float.NaN считается больше любого другого значения, и все значения Float.NaN считаются равными.

Замечание по реализации:: Алгоритм сортировки — это параллельная сортировка-слияние, которая разбивает массив на подмассивы, которые сами по себе отсортированы, а затем сливаются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется с использованием соответствующего метода Arrays.sort. Если длина указанного массива меньше минимальной гранулярности, он сортируется с использованием соответствующего метода Arrays.sort. Алгоритм требует рабочей области не большей, чем размер исходного массива. Для выполнения любых параллельных задач используется ForkJoin common pool.
Параметры:: a — массив, который необходимо отсортировать
С тех пор:: 1.8

parallelSort

public static void parallelSort(float[] a,
                                int fromIndex,
                                int toIndex)

Отношение < не обеспечивает полную упорядоченность для всех значений типа float: -0.0f == 0.0f является true и значение Float.NaN не сравнивается ни меньше, ни больше, ни равно любому значению, даже самому себе. Этот метод использует полную упорядоченность, задаваемую методом Float.compareTo(java.lang.Float): -0.0f рассматривается как меньше значения 0.0f, а Float.NaN считается больше любого другого значения, и все значения Float.NaN считаются равными.

Замечание по реализации:: Алгоритм сортировки — это параллельная сортировка-слияние, которая разбивает массив на подмассивы, которые сами по себе отсортированы, а затем сливаются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется с использованием соответствующего метода Arrays.sort. Если длина указанного массива меньше минимальной гранулярности, он сортируется с использованием соответствующего метода 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)

Сортирует указанный массив в порядке возрастания числовых значений.

Отношение < не обеспечивает полную упорядоченность для всех значений типа double: -0.0d == 0.0d является true и значение Double.NaN не сравнивается ни меньше, ни больше, ни равно любому значению, даже самому себе. Этот метод использует полную упорядоченность, задаваемую методом Double.compareTo(java.lang.Double): -0.0d рассматривается как меньше значения 0.0d, а Double.NaN считается больше любого другого значения, и все значения Double.NaN считаются равными.

Замечание по реализации:: Алгоритм сортировки — это параллельная сортировка-слияние, которая разбивает массив на подмассивы, которые сами по себе отсортированы, а затем сливаются. Когда длина подмассива достигает минимальной гранулярности, подмассив сортируется с использованием соответствующего метода Arrays.sort. Если длина указанного массива меньше минимальной гранулярности, он сортируется с использованием соответствующего метода Arrays.sort. Алгоритм требует рабочей области не большей, чем размер исходного массива. Для выполнения любых параллельных задач используется ForkJoin common pool.
Параметры:: a — массив, который необходимо отсортировать
С тех пор:: 1.8

parallelSort

public static void parallelSort(double[] a,
                                int fromIndex,
                                int toIndex)

Примечание к реализации:: Алгоритм сортировки — это параллельная сортировка-слияние, разбивающая массив на подмассивы, которые сами по себе отсортированы, а затем сливаются. Когда длина подмассива достигает минимальной размерности, подмассив сортируется с помощью соответствующего метода Arrays.sort. Если длина заданного массива меньше минимальной размерности, то он сортируется с помощью соответствующего метода 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) не должно выбрасывать ClassCastException для любых элементов e1 и e2 в массиве).

Эта сортировка гарантированно является стабильной: равные элементы не будут переупорядочены в результате сортировки.

Примечание к реализации:: Алгоритм сортировки — это параллельная сортировка-слияние, разбивающая массив на подмассивы, которые сами по себе отсортированы, а затем сливаются. Когда длина подмассива достигает минимальной размерности, подмассив сортируется с помощью соответствующего метода Arrays.sort. Если длина заданного массива меньше минимальной размерности, то он сортируется с помощью соответствующего метода Arrays.sort. Алгоритм требует рабочей области, не превышающей размера исходного массива. Для выполнения любых параллельных задач используется ForkJoin common pool.
Параметры типа:: T — класс объектов, которые должны быть отсортированы
Параметры:: 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) не должно выбрасывать ClassCastException для любых элементов e1 и e2 в массиве).

Примечание к реализации:: Алгоритм сортировки — это параллельная сортировка-слияние, разбивающая массив на подмассивы, которые сами по себе отсортированы, а затем сливаются. Когда длина подмассива достигает минимальной размерности, подмассив сортируется с помощью соответствующего метода Arrays.sort. Если длина заданного массива меньше минимальной размерности, то он сортируется с помощью соответствующего метода Arrays.sort. Алгоритм требует рабочей области, не превышающей размера заданного диапазона исходного массива. Для выполнения любых параллельных задач используется ForkJoin common pool.
Параметры типа:: T — класс объектов, которые должны быть отсортированы
Параметры:: 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> cmp)

Сортирует указанный массив объектов в соответствии с порядком, заданным указанным компаратором. Все элементы в массиве должны быть взаимосравнимы с помощью указанного компаратора (то есть, c.compare(e1, e2) не должно выбрасывать ClassCastException для любых элементов e1 и e2 в массиве).

Примечание к реализации:: Алгоритм сортировки — это параллельная сортировка-слияние, разбивающая массив на подмассивы, которые сами по себе отсортированы, а затем сливаются. Когда длина подмассива достигает минимальной размерности, подмассив сортируется с помощью соответствующего метода Arrays.sort. Если длина заданного массива меньше минимальной размерности, то он сортируется с помощью соответствующего метода Arrays.sort. Алгоритм требует рабочей области, не превышающей размера исходного массива. Для выполнения любых параллельных задач используется ForkJoin common pool.
Параметры типа:: T — класс объектов, которые должны быть отсортированы
Параметры:: a — массив, подлежащий сортировке; cmp — компаратор для определения порядка массива. Значение null указывает на то, что следует использовать естественный порядок сортировки элементов.
Исключения:: ClassCastException — если массив содержит элементы, которые не являются взаимосравнимыми с помощью указанного компаратора; IllegalArgumentException — (необязательно) если компаратор нарушает контракт Comparator
С момента:: 1.8

parallelSort

public static <T> void parallelSort(T[] a,
                                    int fromIndex,
                                    int toIndex,
                                    Comparator<? super T> cmp)

Сортирует указанный диапазон указанного массива объектов в соответствии с порядком, заданным указанным компаратором. Диапазон, подлежащий сортировке, простирается от индекса fromIndex, включительно, до индекса toIndex, исключая его. (Если fromIndex==toIndex, диапазон, подлежащий сортировке, пустой.) Все элементы в диапазоне должны быть взаимосравнимы с помощью указанного компаратора (то есть, c.compare(e1, e2) не должно выбрасывать ClassCastException для любых элементов e1 и e2 в диапазоне).

Примечание к реализации:: Алгоритм сортировки — это параллельная сортировка-слияние, разбивающая массив на подмассивы, которые сами по себе отсортированы, а затем сливаются. Когда длина подмассива достигает минимальной размерности, подмассив сортируется с помощью соответствующего метода Arrays.sort. Если длина заданного массива меньше минимальной размерности, то он сортируется с помощью соответствующего метода Arrays.sort. Алгоритм требует рабочей области, не превышающей размера заданного диапазона исходного массива. Для выполнения любых параллельных задач используется ForkJoin common pool.
Параметры типа:: T — класс объектов, которые должны быть отсортированы
Параметры:: a — массив, подлежащий сортировке; fromIndex — индекс первого элемента (включительно) для сортировки; toIndex — индекс последнего элемента (исключая его) для сортировки; cmp — компаратор для определения порядка массива. Значение null указывает на то, что следует использовать естественный порядок сортировки элементов.
Исключения:: IllegalArgumentException — если fromIndex > toIndex или (необязательно) если естественный порядок сортировки элементов массива нарушает контракт Comparable; ArrayIndexOutOfBoundsException — если fromIndex < 0 или toIndex > a.length; ClassCastException — если массив содержит элементы, которые не являются взаимосравнимыми (например, строки и целые числа).
С момента:: 1.8

sort

public static void sort(Object[] a)

Сортирует указанный массив объектов в порядке возрастания, согласно естественному порядку его элементов. Все элементы в массиве должны реализовывать интерфейс Comparable. Кроме того, все элементы в массиве должны быть взаимосравнимы (то есть, e1.compareTo(e2) не должно выбрасывать ClassCastException для любых элементов e1 и e2 в массиве).

Эта сортировка гарантированно стабильна: равные элементы не будут переупорядочены в результате сортировки.

Примечание об реализации: Эта реализация — это стабильная, адаптивная, итеративная сортировка слиянием, которая требует намного меньше, чем n lg(n) сравнений, когда входной массив частично отсортирован, предоставляя производительность традиционной сортировки слиянием при случайном порядке входного массива. Если входной массив почти отсортирован, реализация требует примерно n сравнений. Требования к временной памяти варьируются от небольшой константы для почти отсортированных входных массивов до n/2 ссылок на объекты для массивов со случайным порядком.

Реализация одинаково эффективно использует возрастающий и убывающий порядок в своем входном массиве и может использовать возрастающий и убывающий порядок в разных частях одного входного массива. Она хорошо подходит для слияния двух или более отсортированных массивов: просто конкатенируйте массивы и отсортируйте получившийся массив.

Реализация была адаптирована из сортировки списков Tim Peters для Python ( TimSort). Она использует методы из работы Peter McIlroy «Оптимистичная сортировка и информационная сложность», в Трудах четвертой ежегодной конференции ACM-SIAM по дискретным алгоритмам, стр. 467-474, январь 1993 года.

Параметры:: a - массив, который нужно отсортировать
Выбрасывает:: ClassCastException - если массив содержит элементы, которые не являются взаимосравнимыми (например, строки и целые числа); IllegalArgumentException - (необязательно), если естественный порядок элементов массива нарушает контракт Comparable

sort

public static void sort(Object[] a,
                        int fromIndex,
                        int toIndex)

Сортирует указанный диапазон указанного массива объектов в порядке возрастания, согласно естественному порядку его элементов. Диапазон, который необходимо отсортировать, простирается от индекса fromIndex, включительно, до индекса toIndex, не включительно. (Если fromIndex==toIndex, диапазон для сортировки пуст.) Все элементы в этом диапазоне должны реализовывать интерфейс Comparable. Кроме того, все элементы в этом диапазоне должны быть взаимосравнимы (то есть, e1.compareTo(e2) не должно выбрасывать ClassCastException для любых элементов e1 и e2 в массиве).

Параметры:: a - массив, который нужно отсортировать; fromIndex - индекс первого элемента (включительно) для сортировки; toIndex - индекс последнего элемента (исключительно) для сортировки
Выбрасывает:: IllegalArgumentException - если fromIndex > toIndex или (необязательно), если естественный порядок элементов массива нарушает контракт Comparable; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length; ClassCastException - если массив содержит элементы, которые не являются взаимосравнимыми (например, строки и целые числа).

sort

public static <T> void sort(T[] a,
                            Comparator<? super T> c)

Сортирует указанный массив объектов в соответствии с порядком, индуцированным указанным компаратором. Все элементы в массиве должны быть взаимосравнимы с помощью указанного компаратора (то есть, c.compare(e1, e2) не должно выбрасывать ClassCastException для любых элементов e1 и e2 в массиве).

Параметры типа:: T - класс объектов, которые нужно отсортировать
Параметры:: a - массив, который нужно отсортировать; c - компаратор для определения порядка массива. Значение null указывает на использование естественного порядка элементов.
Выбрасывает:: ClassCastException - если массив содержит элементы, которые не являются взаимосравнимыми с использованием указанного компаратора; IllegalArgumentException - (необязательно), если компаратор нарушает контракт Comparator

sort

public static <T> void sort(T[] a,
                            int fromIndex,
                            int toIndex,
                            Comparator<? super T> c)

Сортирует указанный диапазон указанного массива объектов в соответствии с порядком, индуцированным указанным компаратором. Диапазон, который необходимо отсортировать, простирается от индекса fromIndex, включительно, до индекса toIndex, не включительно. (Если fromIndex==toIndex, диапазон для сортировки пуст.) Все элементы в диапазоне должны быть взаимосравнимыми с помощью указанного компаратора (то есть, c.compare(e1, e2) не должно выбрасывать ClassCastException для любых элементов e1 и e2 в диапазоне).

Параметры типа:: T - класс объектов, которые нужно отсортировать
Параметры:: a - массив, который нужно отсортировать; fromIndex - индекс первого элемента (включительно) для сортировки; toIndex - индекс последнего элемента (исключительно) для сортировки; c - компаратор для определения порядка массива. Значение null указывает на использование естественного порядка элементов.
Выбрасывает:: ClassCastException - если массив содержит элементы, которые не являются взаимосравнимыми с использованием указанного компаратора.; IllegalArgumentException - если fromIndex > toIndex или (необязательно), если компаратор нарушает контракт Comparator; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length

parallelPrefix

public static <T> void parallelPrefix(T[] array,
                                      BinaryOperator<T> op)

Вычисляет параллельно и изменяет на месте каждый элемент заданного массива, используя предоставленную функцию. Например, если массив изначально содержит [2, 1, 0, 3] и операция выполняет сложение, то после возвращения массив содержит [2, 3, 3, 6]. Параллельное вычисление префикса обычно более эффективно, чем последовательные циклы, для больших массивов.

Параметры типа:: T - класс объектов в массиве
Параметры:: array - массив, который изменяется на месте этим методом; op - бессосторонняя, ассоциативная функция для выполнения накопления
Выбрасывает:: NullPointerException - если указанный массив или функция равны null
Since:: 1.8

parallelPrefix

public static <T> void parallelPrefix(T[] array,
                                      int fromIndex,
                                      int toIndex,
                                      BinaryOperator<T> op)

Выполняет parallelPrefix(Object[], BinaryOperator) для заданного поддиапазона массива.

Параметры типа:: T - класс объектов в массиве
Параметры:: array - массив; fromIndex - индекс первого элемента (включительно); toIndex - индекс последнего элемента (исключительно); op - свободный от побочных эффектов, ассоциативный функтор для накопления
Исключения:: IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > array.length; NullPointerException - если указанный массив или функтор равен null
С момента:: 1.8

parallelPrefix

public static void parallelPrefix(long[] array,
                                  LongBinaryOperator op)

Накапливает, в параллельном режиме, каждый элемент данного массива на месте, используя предоставленную функцию. Например, если массив изначально содержит [2, 1, 0, 3] и операция выполняет сложение, то по завершении метода массив содержит [2, 3, 3, 6]. Вычисление параллельного префикса обычно более эффективно, чем циклы последовательного выполнения для больших массивов.

Параметры:: array - массив, который модифицируется этим методом на месте; op - свободный от побочных эффектов, ассоциативный функтор для накопления
Исключения:: NullPointerException - если указанный массив или функтор равен null
С момента:: 1.8

parallelPrefix

public static void parallelPrefix(long[] array,
                                  int fromIndex,
                                  int toIndex,
                                  LongBinaryOperator op)

Выполняет parallelPrefix(long[], LongBinaryOperator) для заданного поддиапазона массива.

Параметры:: array - массив; fromIndex - индекс первого элемента (включительно); toIndex - индекс последнего элемента (исключительно); op - свободный от побочных эффектов, ассоциативный функтор для накопления
Исключения:: IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > array.length; NullPointerException - если указанный массив или функтор равен null
С момента:: 1.8

parallelPrefix

public static void parallelPrefix(double[] array,
                                  DoubleBinaryOperator op)

Накапливает, в параллельном режиме, каждый элемент данного массива на месте, используя предоставленную функцию. Например, если массив изначально содержит [2.0, 1.0, 0.0, 3.0] и операция выполняет сложение, то по завершении метода массив содержит [2.0, 3.0, 3.0, 6.0]. Вычисление параллельного префикса обычно более эффективно, чем циклы последовательного выполнения для больших массивов.

Поскольку операции с плавающей запятой могут не быть строго ассоциативными, возвращаемый результат может не совпадать с результатом, полученным при выполнении операции последовательно.

Параметры:: array - массив, который модифицируется этим методом на месте; op - свободный от побочных эффектов функтор для накопления
Исключения:: NullPointerException - если указанный массив или функтор равен null
С момента:: 1.8

parallelPrefix

public static void parallelPrefix(double[] array,
                                  int fromIndex,
                                  int toIndex,
                                  DoubleBinaryOperator op)

Выполняет parallelPrefix(double[], DoubleBinaryOperator) для заданного поддиапазона массива.

Параметры:: array - массив; fromIndex - индекс первого элемента (включительно); toIndex - индекс последнего элемента (исключительно); op - свободный от побочных эффектов, ассоциативный функтор для накопления
Исключения:: IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > array.length; NullPointerException - если указанный массив или функтор равен null
С момента:: 1.8

parallelPrefix

public static void parallelPrefix(int[] array,
                                  IntBinaryOperator op)

Параметры:: array - массив, который модифицируется этим методом на месте; op - свободный от побочных эффектов, ассоциативный функтор для накопления
Исключения:: NullPointerException - если указанный массив или функтор равен null
С момента:: 1.8

parallelPrefix

public static void parallelPrefix(int[] array,
                                  int fromIndex,
                                  int toIndex,
                                  IntBinaryOperator op)

Выполняет parallelPrefix(int[], IntBinaryOperator) для заданного поддиапазона массива.

Параметры:: array - массив; fromIndex - индекс первого элемента (включительно); toIndex - индекс последнего элемента (исключительно); op - свободный от побочных эффектов, ассоциативный функтор для накопления
Исключения:: IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > array.length; NullPointerException - если указанный массив или функтор равен null
С момента:: 1.8

binarySearch

public static int binarySearch(long[] a,
                               long key)

Ищет указанное значение в заданном отсортированном массиве long с использованием алгоритма двоичного поиска. Массив должен быть отсортирован (например, методом sort(long[])) перед вызовом этого метода. Если массив не отсортирован, результаты будут неопределенными. Если массив содержит несколько элементов с указанным значением, нет гарантии, какой из них будет найден.

Параметры:: a - массив для поиска; key - искомое значение
Возвращаемое значение:: индекс искомого ключа, если он содержится в массиве; в противном случае (-(insertion point) - 1). Точка вставки определяется как точка, в которую ключ был бы вставлен в массив: индекс первого элемента, большего ключа, или a.length если все элементы массива меньше указанного ключа. Это гарантирует, что возвращаемое значение будет >= 0 только в том случае, если ключ найден.

binarySearch

public static int binarySearch(long[] a,
                               int fromIndex,
                               int toIndex,
                               long key)

Ищет указанное значение в заданном поддиапазоне отсортированного массива long с использованием алгоритма двоичного поиска. Поддиапазон должен быть отсортирован (как методом 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)

Ищет указанное значение в заданном отсортированном массиве int с использованием алгоритма двоичного поиска. Массив должен быть отсортирован (например, методом sort(int[])) перед вызовом этого метода. Если массив не отсортирован, результаты будут неопределенными. Если массив содержит несколько элементов с указанным значением, нет гарантии, какой из них будет найден.

Параметры:: a - массив для поиска; key - искомое значение
Возвращаемое значение:: индекс искомого ключа, если он содержится в массиве; в противном случае (-(insertion point) - 1). Точка вставки определяется как точка, в которую ключ был бы вставлен в массив: индекс первого элемента, большего ключа, или a.length если все элементы массива меньше указанного ключа. Это гарантирует, что возвращаемое значение будет >= 0 только в том случае, если ключ найден.

binarySearch

public static int binarySearch(int[] a,
                               int fromIndex,
                               int toIndex,
                               int key)

Ищет указанное значение в заданном поддиапазоне отсортированного массива int с использованием алгоритма двоичного поиска. Поддиапазон должен быть отсортирован (например, методом 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)

Ищет указанное значение в заданном массиве целых чисел типа short с помощью алгоритма бинарного поиска. Массив должен быть отсортирован (как методом sort(short[])) перед вызовом этого метода. Если массив не отсортирован, результаты будут неопределёнными. Если массив содержит несколько элементов с указанным значением, нет гарантии, какой из них будет найден.

Параметры:: a - массив для поиска; key - значение, которое нужно найти
Возвращает:: индекс искомого ключа, если он содержится в массиве; в противном случае, (-(insertion point) - 1). Точка вставки определяется как точка, в которую ключ был бы вставлен в массив: индекс первого элемента, большего ключа, или a.length если все элементы массива меньше указанного ключа. Обратите внимание, что это гарантирует, что возвращаемое значение будет >= 0 только в том случае, если ключ найден.

binarySearch

public static int binarySearch(short[] a,
                               int fromIndex,
                               int toIndex,
                               short key)

Ищет указанное значение в заданном диапазоне массива целых чисел типа short с помощью алгоритма бинарного поиска. Диапазон должен быть отсортирован (как методом 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)

Ищет указанное значение в заданном массиве символов типа char с помощью алгоритма бинарного поиска. Массив должен быть отсортирован (как методом sort(char[])) перед вызовом этого метода. Если массив не отсортирован, результаты будут неопределёнными. Если массив содержит несколько элементов с указанным значением, нет гарантии, какой из них будет найден.

Параметры:: a - массив для поиска; key - значение, которое нужно найти
Возвращает:: индекс искомого ключа, если он содержится в массиве; в противном случае, (-(insertion point) - 1). Точка вставки определяется как точка, в которую ключ был бы вставлен в массив: индекс первого элемента, большего ключа, или a.length если все элементы массива меньше указанного ключа. Обратите внимание, что это гарантирует, что возвращаемое значение будет >= 0 только в том случае, если ключ найден.

binarySearch

public static int binarySearch(char[] a,
                               int fromIndex,
                               int toIndex,
                               char key)

Ищет указанное значение в заданном диапазоне массива символов типа char с помощью алгоритма бинарного поиска. Диапазон должен быть отсортирован (как методом 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)

Ищет указанное значение в заданном массиве чисел типа double с помощью алгоритма бинарного поиска. Массив должен быть отсортирован (как методом sort(double[])) перед вызовом этого метода. Если массив не отсортирован, результаты будут неопределёнными. Если массив содержит несколько элементов с указанным значением, нет гарантии, какой из них будет найден. Этот метод рассматривает все значения NaN как эквивалентные и равные.

Параметры:: a - массив для поиска; key - значение, которое нужно найти
Возвращает:: индекс искомого ключа, если он содержится в массиве; в противном случае, (-(insertion point) - 1). Точка вставки определяется как точка, в которую ключ был бы вставлен в массив: индекс первого элемента, большего ключа, или a.length если все элементы массива меньше указанного ключа. Обратите внимание, что это гарантирует, что возвращаемое значение будет >= 0 только в том случае, если ключ найден.

binarySearch

public static int binarySearch(double[] a,
                               int fromIndex,
                               int toIndex,
                               double key)

Ищет указанное значение в заданном диапазоне массива чисел типа double с помощью алгоритма бинарного поиска. Диапазон должен быть отсортирован (как методом sort(double[], int, int)) перед вызовом этого метода. Если диапазон не отсортирован, результаты будут неопределёнными. Если диапазон содержит несколько элементов с указанным значением, нет гарантии, какой из них будет найден. Этот метод рассматривает все значения NaN как эквивалентные и равные.

Параметры:: 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)

Ищет указанное значение в заданном массиве чисел типа float с помощью алгоритма бинарного поиска. Массив должен быть отсортирован (как методом sort(float[])) перед вызовом этого метода. Если массив не отсортирован, результаты будут неопределёнными. Если массив содержит несколько элементов с указанным значением, нет гарантии, какой из них будет найден. Этот метод рассматривает все значения NaN как эквивалентные и равные.

Параметры:: 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)) перед вызовом этого метода. Если он не отсортирован, результаты не определены. Если диапазон содержит несколько элементов с указанным значением, нет гарантии, какой из них будет найден. Этот метод рассматривает все значения NaN как эквивалентные и равные.

Параметры:: 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)) перед вызовом этого метода. Если он не отсортирован, результаты не определены. Если массив содержит несколько элементов, равных указанному объекту, нет гарантии, какой из них будет найден.

Параметры типа:: T - класс объектов в массиве
Параметры:: 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)) перед вызовом этого метода. Если он не отсортирован, результаты не определены. Если диапазон содержит несколько элементов, равных указанному объекту, нет гарантии, какой из них будет найден.

Параметры типа:: T - класс объектов в массиве
Параметры:: a - массив, который нужно просмотреть; fromIndex - индекс первого элемента (включительно) для поиска; toIndex - индекс последнего элемента (исключительно) для поиска; key - значение, которое нужно найти; c - компаратор, по которому отсортирован массив. Значение null указывает, что следует использовать естественный порядок элементов.
Возвращает:: индекс ключа поиска, если он содержится в массиве в указанном диапазоне; в противном случае, (-(insertion point) - 1). Точка вставки определяется как точка, в которой ключ был бы вставлен в массив: индекс первого элемента в диапазоне, большего ключа, или toIndex, если все элементы в диапазоне меньше указанного ключа. Обратите внимание, что это гарантирует, что возвращаемое значение будет >= 0 тогда и только тогда, когда ключ найден.
Исключение:: ClassCastException - если диапазон содержит элементы, которые не являются взаимосравнимыми с использованием указанного компаратора, или ключ поиска не сравним с элементами в диапазоне с использованием этого компаратора.; IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 or toIndex > a.length
С:: 1.6

equals

public static boolean equals(long[] a,
                             long[] a2)

Возвращает true , если два указанных массива длинных чисел равны друг другу. Два массива считаются равными, если оба массива содержат одинаковое количество элементов, и все соответствующие пары элементов в двух массивах равны. Другими словами, два массива равны, если они содержат одинаковые элементы в том же порядке. Также, две ссылки на массивы считаются равными, если обе являются null.

Параметры:: a - один массив, который нужно проверить на равенство; a2 - другой массив, который нужно проверить на равенство
Возвращает:: true , если два массива равны

equals

public static boolean equals(long[] a,
                             int aFromIndex,
                             int aToIndex,
                             long[] b,
                             int bFromIndex,
                             int bToIndex)

Возвращает true, если два указанных массива длинных чисел в указанных диапазонах равны друг другу.

Два массива считаются равными, если количество элементов, охватываемых каждым диапазоном, одинаково, и все соответствующие пары элементов в указанных диапазонах в двух массивах равны. Другими словами, два массива равны, если они содержат в указанных диапазонах одинаковые элементы в том же порядке.

Параметры:: a - первый массив, подлежащий проверке на равенство; aFromIndex - индекс (включительно) первого элемента в первом массиве, подлежащем проверке; aToIndex - индекс (исключительно) последнего элемента в первом массиве, подлежащем проверке; b - второй массив, подлежащий проверке на равенство; bFromIndex - индекс (включительно) первого элемента во втором массиве, подлежащем проверке; bToIndex - индекс (исключительно) последнего элемента во втором массиве, подлежащем проверке
Возвращает:: true если два массива в заданных диапазонах равны
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С тех пор как:: 9

equals

public static boolean equals(int[] a,
                             int[] a2)

Возвращает true если два указанных массива целых чисел равны друг другу. Два массива считаются равными, если оба массива содержат одинаковое количество элементов и все соответствующие пары элементов в двух массивах равны. Другими словами, два массива равны, если они содержат одинаковые элементы в том же порядке. Также две ссылки на массив считаются равными, если обе null.

Параметры:: a - один массив, подлежащий проверке на равенство; a2 - другой массив, подлежащий проверке на равенство
Возвращает:: true если два массива равны

equals

public static boolean equals(int[] a,
                             int aFromIndex,
                             int aToIndex,
                             int[] b,
                             int bFromIndex,
                             int bToIndex)

Возвращает true, если два указанных массива целых чисел в заданных диапазонах равны друг другу.

Два массива считаются равными, если количество элементов, охватываемых каждым диапазоном, одинаково, и все соответствующие пары элементов в заданных диапазонах в двух массивах равны. Другими словами, два массива равны, если они содержат в заданных диапазонах одинаковые элементы в том же порядке.

Параметры:: a - первый массив, подлежащий проверке на равенство; aFromIndex - индекс (включительно) первого элемента в первом массиве, подлежащем проверке; aToIndex - индекс (исключительно) последнего элемента в первом массиве, подлежащем проверке; b - второй массив, подлежащий проверке на равенство; bFromIndex - индекс (включительно) первого элемента во втором массиве, подлежащем проверке; bToIndex - индекс (исключительно) последнего элемента во втором массиве, подлежащем проверке
Возвращает:: true если два массива в заданных диапазонах равны
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С тех пор как:: 9

equals

public static boolean equals(short[] a,
                             short[] a2)

Возвращает true если два указанных массива коротких целых чисел равны друг другу. Два массива считаются равными, если оба массива содержат одинаковое количество элементов и все соответствующие пары элементов в двух массивах равны. Другими словами, два массива равны, если они содержат одинаковые элементы в том же порядке. Также две ссылки на массив считаются равными, если обе null.

Параметры:: a - один массив, подлежащий проверке на равенство; a2 - другой массив, подлежащий проверке на равенство
Возвращает:: true если два массива равны

equals

public static boolean equals(short[] a,
                             int aFromIndex,
                             int aToIndex,
                             short[] b,
                             int bFromIndex,
                             int bToIndex)

Возвращает true, если два указанных массива коротких целых чисел в заданных диапазонах равны друг другу.

Параметры:: a - первый массив, подлежащий проверке на равенство; aFromIndex - индекс (включительно) первого элемента в первом массиве, подлежащем проверке; aToIndex - индекс (исключительно) последнего элемента в первом массиве, подлежащем проверке; b - второй массив, подлежащий проверке на равенство; bFromIndex - индекс (включительно) первого элемента во втором массиве, подлежащем проверке; bToIndex - индекс (исключительно) последнего элемента во втором массиве, подлежащем проверке
Возвращает:: true если два массива в заданных диапазонах равны
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С тех пор как:: 9

equals

public static boolean equals(char[] a,
                             char[] a2)

Возвращает true если два указанных массива символов равны друг другу. Два массива считаются равными, если оба массива содержат одинаковое количество элементов и все соответствующие пары элементов в двух массивах равны. Другими словами, два массива равны, если они содержат одинаковые элементы в том же порядке. Также две ссылки на массив считаются равными, если обе null.

Параметры:: a - один массив, подлежащий проверке на равенство; a2 - другой массив, подлежащий проверке на равенство
Возвращает:: true если два массива равны

equals

public static boolean equals(char[] a,
                             int aFromIndex,
                             int aToIndex,
                             char[] b,
                             int bFromIndex,
                             int bToIndex)

Возвращает true, если два указанных массива символов в заданных диапазонах равны друг другу.

Параметры:: a - первый массив, подлежащий проверке на равенство; aFromIndex - индекс (включительно) первого элемента в первом массиве, подлежащем проверке; aToIndex - индекс (исключительно) последнего элемента в первом массиве, подлежащем проверке; b - второй массив, подлежащий проверке на равенство; bFromIndex - индекс (включительно) первого элемента во втором массиве, подлежащем проверке; bToIndex - индекс (исключительно) последнего элемента во втором массиве, подлежащем проверке
Возвращает:: true если два массива в заданных диапазонах равны
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С тех пор как:: 9

equals

public static boolean equals(byte[] a,
                             byte[] a2)

Возвращает true если два указанных массива байтов равны друг другу. Два массива считаются равными, если оба массива содержат одинаковое количество элементов и все соответствующие пары элементов в двух массивах равны. Другими словами, два массива равны, если они содержат одинаковые элементы в том же порядке. Также две ссылки на массив считаются равными, если обе null.

Параметры:: a - один массив, подлежащий проверке на равенство; a2 - другой массив, подлежащий проверке на равенство
Возвращает:: true если два массива равны

equals

public static boolean equals(byte[] a,
                             int aFromIndex,
                             int aToIndex,
                             byte[] b,
                             int bFromIndex,
                             int bToIndex)

Возвращает true, если два указанных массива байтов в заданных диапазонах равны друг другу.

Параметры:: a - первый массив, подлежащий проверке на равенство; aFromIndex - индекс (включительно) первого элемента в первом массиве, подлежащем проверке; aToIndex - индекс (исключительно) последнего элемента в первом массиве, подлежащем проверке; b - второй массив, подлежащий проверке на равенство; bFromIndex - индекс (включительно) первого элемента во втором массиве, подлежащем проверке; bToIndex - индекс (исключительно) последнего элемента во втором массиве, подлежащем проверке
Возвращает:: true если два массива в заданных диапазонах равны
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С тех пор как:: 9

equals

public static boolean equals(boolean[] a,
                             boolean[] a2)

Возвращает true если два указанных массива булевых значений равны друг другу. Два массива считаются равными, если оба массива содержат одинаковое количество элементов и все соответствующие пары элементов в двух массивах равны. Другими словами, два массива равны, если они содержат одинаковые элементы в том же порядке. Также две ссылки на массив считаются равными, если обе null.

Параметры:: a - один массив, подлежащий проверке на равенство; a2 - другой массив, подлежащий проверке на равенство
Возвращает:: true если два массива равны

equals

public static boolean equals(boolean[] a,
                             int aFromIndex,
                             int aToIndex,
                             boolean[] b,
                             int bFromIndex,
                             int bToIndex)

Возвращает true, если два заданных массива булевых значений в указанных диапазонах равны друг другу.

Два массива считаются равными, если количество элементов, охватываемых каждым диапазоном, одинаково, и все соответствующие пары элементов в указанных диапазонах двух массивов равны. Другими словами, два массива равны, если они содержат в указанных диапазонах одни и те же элементы в том же порядке.

Параметры:: a - первый массив, проверяемый на равенство; aFromIndex - индекс (включительно) первого элемента в первом массиве, который проверяется; aToIndex - индекс (исключительно) последнего элемента в первом массиве, который проверяется; b - второй массив, проверяемый на равенство; bFromIndex - индекс (включительно) первого элемента во втором массиве, который проверяется; bToIndex - индекс (исключительно) последнего элемента во втором массиве, который проверяется
Возвращает:: true если два массива в указанных диапазонах равны
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С:: 9

equals

public static boolean equals(double[] a,
                             double[] a2)

Возвращает true если два заданных массива типа double равны друг другу. Два массива считаются равными, если оба массива содержат одинаковое количество элементов и все соответствующие пары элементов в двух массивах равны. Другими словами, два массива равны, если они содержат одни и те же элементы в том же порядке. Также, две ссылки на массивы считаются равными, если обе являются null. Два значения типа double d1 и d2 считаются равными, если:

new Double(d1).equals(new Double(d2))

(В отличие от оператора ==, этот метод считает NaN равным самому себе и 0.0d не равным -0.0d.)

Параметры:: a - один массив, проверяемый на равенство; a2 - другой массив, проверяемый на равенство
Возвращает:: true если два массива равны
См. также:: Double.equals(Object)

equals

public static boolean equals(double[] a,
                             int aFromIndex,
                             int aToIndex,
                             double[] b,
                             int bFromIndex,
                             int bToIndex)

Возвращает true, если два заданных массива типа double в указанных диапазонах равны друг другу.

Два значения типа double d1 и d2 считаются равными, если:

new Double(d1).equals(new Double(d2))

(В отличие от оператора ==, этот метод считает NaN равным самому себе и 0.0d не равным -0.0d.)

Параметры:: a - первый массив, проверяемый на равенство; aFromIndex - индекс (включительно) первого элемента в первом массиве, который проверяется; aToIndex - индекс (исключительно) последнего элемента в первом массиве, который проверяется; b - второй массив, проверяемый на равенство; bFromIndex - индекс (включительно) первого элемента во втором массиве, который проверяется; bToIndex - индекс (исключительно) последнего элемента во втором массиве, который проверяется
Возвращает:: true если два массива в указанных диапазонах равны
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С:: 9
См. также:: Double.equals(Object)

equals

public static boolean equals(float[] a,
                             float[] a2)

Возвращает true если два заданных массива типа float равны друг другу. Два массива считаются равными, если оба массива содержат одинаковое количество элементов и все соответствующие пары элементов в двух массивах равны. Другими словами, два массива равны, если они содержат одни и те же элементы в том же порядке. Также, две ссылки на массивы считаются равными, если обе являются null. Два значения типа float f1 и f2 считаются равными, если:

new Float(f1).equals(new Float(f2))

(В отличие от оператора ==, этот метод считает NaN равным самому себе и 0.0f не равным -0.0f.)

Параметры:: a - один массив, проверяемый на равенство; a2 - другой массив, проверяемый на равенство
Возвращает:: true если два массива равны
См. также:: Float.equals(Object)

equals

public static boolean equals(float[] a,
                             int aFromIndex,
                             int aToIndex,
                             float[] b,
                             int bFromIndex,
                             int bToIndex)

Возвращает true, если два заданных массива типа float в указанных диапазонах равны друг другу.

Два значения типа float f1 и f2 считаются равными, если:

new Float(f1).equals(new Float(f2))

(В отличие от оператора ==, этот метод считает NaN равным самому себе и 0.0f не равным -0.0f.)

Параметры:: a - первый массив, проверяемый на равенство; aFromIndex - индекс (включительно) первого элемента в первом массиве, который проверяется; aToIndex - индекс (исключительно) последнего элемента в первом массиве, который проверяется; b - второй массив, проверяемый на равенство; bFromIndex - индекс (включительно) первого элемента во втором массиве, который проверяется; bToIndex - индекс (исключительно) последнего элемента во втором массиве, который проверяется
Возвращает:: true если два массива в указанных диапазонах равны
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С:: 9
См. также:: Float.equals(Object)

equals

public static boolean equals(Object[] a,
                             Object[] a2)

Возвращает true если два заданных массива объектов равны друг другу. Два массива считаются равными, если оба массива содержат одинаковое количество элементов и все соответствующие пары элементов в двух массивах равны. Два объекта e1 и e2 считаются равными, если Objects.equals(e1, e2). Другими словами, два массива равны, если они содержат одни и те же элементы в том же порядке. Также, две ссылки на массивы считаются равными, если обе являются null.

Параметры:: a - один массив, проверяемый на равенство; a2 - другой массив, проверяемый на равенство
Возвращает:: true если два массива равны

equals

public static boolean equals(Object[] a,
                             int aFromIndex,
                             int aToIndex,
                             Object[] b,
                             int bFromIndex,
                             int bToIndex)

Возвращает true, если два заданных массива объектов в указанных диапазонах равны друг другу.

Два объекта e1 и e2 считаются равными, если Objects.equals(e1, e2).

Параметры:: a - первый массив, проверяемый на равенство; aFromIndex - индекс (включительно) первого элемента в первом массиве, который проверяется; aToIndex - индекс (исключительно) последнего элемента в первом массиве, который проверяется; b - второй массив, проверяемый на равенство; bFromIndex - индекс (включительно) первого элемента во втором массиве, который проверяется; bToIndex - индекс (исключительно) последнего элемента во втором массиве, который проверяется
Возвращает:: true если два массива в указанных диапазонах равны
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С:: 9

equals

public static <T> boolean equals(T[] a,
                                 T[] a2,
                                 Comparator<? super T> cmp)

Возвращает true если два заданных массива объектов равны друг другу.

Два массива считаются равными, если оба массива содержат одинаковое количество элементов и все соответствующие пары элементов в двух массивах равны. Другими словами, два массива равны, если они содержат одни и те же элементы в том же порядке. Также, две ссылки на массивы считаются равными, если обе являются null.

Два объекта e1 и e2 считаются равными, если, с учетом заданного компаратора, cmp.compare(e1, e2) == 0.

Параметры типа:: T - the type of array elements
Параметры:: a - one array to be tested for equality; a2 - the other array to be tested for equality; cmp - the comparator to compare array elements
Возвращает:: true if the two arrays are equal
Исключения:: NullPointerException - if the comparator is null
С версии:: 9

equals

public static <T> boolean equals(T[] a,
                                 int aFromIndex,
                                 int aToIndex,
                                 T[] b,
                                 int bFromIndex,
                                 int bToIndex,
                                 Comparator<? super T> cmp)

Возвращает true, если два указанных массива объектов, в указанных диапазонах, равны друг другу.

Два массива считаются равными, если количество элементов, охватываемых каждым диапазоном, одинаково, и все соответствующие пары элементов в указанных диапазонах в двух массивах равны. Другими словами, два массива равны, если они содержат, в указанных диапазонах, одни и те же элементы в одном и том же порядке.

Два объекта e1 и e2 считаются равными, если, с учетом указанного компаратора, cmp.compare(e1, e2) == 0.

Параметры типа:: T - the type of array elements
Параметры:: a - the first array to be tested for equality; aFromIndex - the index (inclusive) of the first element in the first array to be tested; aToIndex - the index (exclusive) of the last element in the first array to be tested; b - the second array to be tested fro equality; bFromIndex - the index (inclusive) of the first element in the second array to be tested; bToIndex - the index (exclusive) of the last element in the second array to be tested; cmp - the comparator to compare array elements
Возвращает:: true if the two arrays, over the specified ranges, are equal
Исключения:: IllegalArgumentException - if aFromIndex > aToIndex or if bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - if aFromIndex < 0 or aToIndex > a.length or if bFromIndex < 0 or bToIndex > b.length; NullPointerException - if either array or the comparator is null
С версии:: 9

fill

public static void fill(long[] a,
                        long val)

Присваивает указанное значение long каждому элементу указанного массива long.

Параметры:: a - the array to be filled; val - the value to be stored in all elements of the array

fill

public static void fill(long[] a,
                        int fromIndex,
                        int toIndex,
                        long val)

Присваивает указанное значение long каждому элементу указанного диапазона указанного массива long. Заполняемый диапазон простирается от индекса fromIndex, включительно, до индекса toIndex, не включительно. (Если fromIndex==toIndex, заполняемый диапазон пуст.)

Параметры:: a - the array to be filled; fromIndex - the index of the first element (inclusive) to be filled with the specified value; toIndex - the index of the last element (exclusive) to be filled with the specified value; val - the value to be stored in all elements of the array
Исключения:: IllegalArgumentException - if fromIndex > toIndex; ArrayIndexOutOfBoundsException - if fromIndex < 0 or toIndex > a.length

fill

public static void fill(int[] a,
                        int val)

Присваивает указанное значение int каждому элементу указанного массива int.

Параметры:: a - the array to be filled; val - the value to be stored in all elements of the array

fill

public static void fill(int[] a,
                        int fromIndex,
                        int toIndex,
                        int val)

Присваивает указанное значение int каждому элементу указанного диапазона указанного массива int. Заполняемый диапазон простирается от индекса fromIndex, включительно, до индекса toIndex, не включительно. (Если fromIndex==toIndex, заполняемый диапазон пуст.)

Параметры:: a - the array to be filled; fromIndex - the index of the first element (inclusive) to be filled with the specified value; toIndex - the index of the last element (exclusive) to be filled with the specified value; val - the value to be stored in all elements of the array
Исключения:: IllegalArgumentException - if fromIndex > toIndex; ArrayIndexOutOfBoundsException - if fromIndex < 0 or toIndex > a.length

fill

public static void fill(short[] a,
                        short val)

Присваивает указанное значение short каждому элементу указанного массива short.

Параметры:: a - the array to be filled; val - the value to be stored in all elements of the array

fill

public static void fill(short[] a,
                        int fromIndex,
                        int toIndex,
                        short val)

Присваивает указанное значение short каждому элементу указанного диапазона указанного массива short. Заполняемый диапазон простирается от индекса fromIndex, включительно, до индекса toIndex, не включительно. (Если fromIndex==toIndex, заполняемый диапазон пуст.)

Параметры:: a - the array to be filled; fromIndex - the index of the first element (inclusive) to be filled with the specified value; toIndex - the index of the last element (exclusive) to be filled with the specified value; val - the value to be stored in all elements of the array
Исключения:: IllegalArgumentException - if fromIndex > toIndex; ArrayIndexOutOfBoundsException - if fromIndex < 0 or toIndex > a.length

fill

public static void fill(char[] a,
                        char val)

Присваивает указанное значение char каждому элементу указанного массива char.

Параметры:: a - the array to be filled; val - the value to be stored in all elements of the array

fill

public static void fill(char[] a,
                        int fromIndex,
                        int toIndex,
                        char val)

Присваивает указанное значение char каждому элементу указанного диапазона указанного массива char. Заполняемый диапазон простирается от индекса fromIndex, включительно, до индекса toIndex, не включительно. (Если fromIndex==toIndex, заполняемый диапазон пуст.)

Параметры:: a - the array to be filled; fromIndex - the index of the first element (inclusive) to be filled with the specified value; toIndex - the index of the last element (exclusive) to be filled with the specified value; val - the value to be stored in all elements of the array
Исключения:: IllegalArgumentException - if fromIndex > toIndex; ArrayIndexOutOfBoundsException - if fromIndex < 0 or toIndex > a.length

fill

public static void fill(byte[] a,
                        byte val)

Присваивает указанное значение byte каждому элементу указанного массива byte.

Параметры:: a - the array to be filled; val - the value to be stored in all elements of the array

fill

public static void fill(byte[] a,
                        int fromIndex,
                        int toIndex,
                        byte val)

Присваивает указанное значение byte каждому элементу указанного диапазона указанного массива byte. Заполняемый диапазон простирается от индекса fromIndex, включительно, до индекса toIndex, не включительно. (Если fromIndex==toIndex, заполняемый диапазон пуст.)

Параметры:: a - the array to be filled; fromIndex - the index of the first element (inclusive) to be filled with the specified value; toIndex - the index of the last element (exclusive) to be filled with the specified value; val - the value to be stored in all elements of the array
Исключения:: IllegalArgumentException - if fromIndex > toIndex; ArrayIndexOutOfBoundsException - if fromIndex < 0 or toIndex > a.length

fill

public static void fill(boolean[] a,
                        boolean val)

Присваивает указанное значение boolean каждому элементу указанного массива boolean.

Параметры:: a - the array to be filled; val - the value to be stored in all elements of the array

fill

public static void fill(boolean[] a,
                        int fromIndex,
                        int toIndex,
                        boolean val)

Присваивает указанное значение boolean каждому элементу указанного диапазона указанного массива boolean. Заполняемый диапазон простирается от индекса fromIndex, включительно, до индекса toIndex, не включительно. (Если fromIndex==toIndex, заполняемый диапазон пуст.)

Параметры:: a - the array to be filled; fromIndex - the index of the first element (inclusive) to be filled with the specified value; toIndex - the index of the last element (exclusive) to be filled with the specified value; val - the value to be stored in all elements of the array
Исключения:: IllegalArgumentException - if fromIndex > toIndex; ArrayIndexOutOfBoundsException - if fromIndex < 0 or toIndex > a.length

fill

public static void fill(double[] a,
                        double val)

Присваивает указанное значение double каждому элементу указанного массива double.

Параметры:: a - the array to be filled; val - the value to be stored in all elements of the array

fill

public static void fill(double[] a,
                        int fromIndex,
                        int toIndex,
                        double val)

Присваивает указанное значение double каждому элементу указанного диапазона указанного массива double. Заполняемый диапазон простирается от индекса fromIndex, включительно, до индекса toIndex, не включительно. (Если fromIndex==toIndex, заполняемый диапазон пуст.)

Параметры:: a - массив, который будет заполнен; fromIndex - индекс первого элемента (включительно), который будет заполнен указанным значением; toIndex - индекс последнего элемента (исключительно), который будет заполнен указанным значением; val - значение, которое будет храниться во всех элементах массива
Исключения:: IllegalArgumentException - если fromIndex > toIndex; ArrayIndexOutOfBoundsException - если fromIndex < 0 или toIndex > a.length

fill

public static void fill(float[] a,
                        float val)

Присваивает указанное значение с плавающей точкой каждому элементу указанного массива с плавающей точкой.

Параметры:: a - массив, который будет заполнен; val - значение, которое будет храниться во всех элементах массива

fill

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

fill

public static void fill(Object[] a,
                        Object val)

Присваивает указанную ссылку на объект каждому элементу указанного массива объектов.

Параметры:: a - массив, который будет заполнен; val - значение, которое будет храниться во всех элементах массива
Исключения:: ArrayStoreException - если указанное значение не является объектом runtime-типа, который может быть сохранён в указанном массиве

fill

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 - если указанное значение не является объектом runtime-типа, который может быть сохранён в указанном массиве

copyOf

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

Копирует указанный массив, обрезая или заполняя нулями (при необходимости), чтобы копия имела указанную длину. Для всех индексов, которые являются допустимыми как в исходном массиве, так и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не в оригинале, копия будет содержать null. Такие индексы будут существовать тогда и только тогда, когда указанная длина больше, чем длина исходного массива. Результирующий массив имеет точно такой же класс, как и исходный массив.

Параметры типа:: T - класс объектов в массиве
Параметры:: original - массив, который будет скопирован; newLength - длина возвращаемой копии
Возвращает:: копию исходного массива, обрезав или дополнив нулями, чтобы получить указанную длину
Исключения:: NegativeArraySizeException - если newLength отрицательно; NullPointerException - если original равен null
С:: 1.6

copyOf

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

Параметры типа:: U - класс объектов в исходном массиве; T - класс объектов в возвращаемом массиве
Параметры:: original - массив, который будет скопирован; newLength - длина возвращаемой копии; newType - класс возвращаемой копии
Возвращает:: копию исходного массива, обрезав или дополнив нулями, чтобы получить указанную длину
Исключения:: NegativeArraySizeException - если newLength отрицательно; NullPointerException - если original равен null; ArrayStoreException - если элемент, скопированный из original, не является объектом runtime-типа, который может быть сохранён в массиве класса newType
С:: 1.6

copyOf

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

Копирует указанный массив, обрезая или заполняя нулями (если необходимо), чтобы копия имела указанную длину. Для всех индексов, которые являются допустимыми как в исходном массиве, так и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не в оригинале, копия будет содержать (byte)0. Такие индексы будут существовать тогда и только тогда, когда указанная длина больше, чем длина исходного массива.

Параметры:: original - массив, который будет скопирован; newLength - длина возвращаемой копии
Возвращает:: копию исходного массива, обрезав или дополнив нулями, чтобы получить указанную длину
Исключения:: NegativeArraySizeException - если newLength отрицательно; NullPointerException - если original равен null
С:: 1.6

copyOf

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

Копирует указанный массив, обрезая или заполняя нулями (если необходимо), чтобы копия имела указанную длину. Для всех индексов, которые являются допустимыми как в исходном массиве, так и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не в оригинале, копия будет содержать (short)0. Такие индексы будут существовать тогда и только тогда, когда указанная длина больше, чем длина исходного массива.

Параметры:: original - массив, который будет скопирован; newLength - длина возвращаемой копии
Возвращает:: копию исходного массива, обрезав или дополнив нулями, чтобы получить указанную длину
Исключения:: NegativeArraySizeException - если newLength отрицательно; NullPointerException - если original равен null
С:: 1.6

copyOf

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

Копирует указанный массив, обрезая или заполняя нулями (если необходимо), чтобы копия имела указанную длину. Для всех индексов, которые являются допустимыми как в исходном массиве, так и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не в оригинале, копия будет содержать 0. Такие индексы будут существовать тогда и только тогда, когда указанная длина больше, чем длина исходного массива.

Параметры:: original - массив, который будет скопирован; newLength - длина возвращаемой копии
Возвращает:: копию исходного массива, обрезав или дополнив нулями, чтобы получить указанную длину
Исключения:: NegativeArraySizeException - если newLength отрицательно; NullPointerException - если original равен null
С:: 1.6

copyOf

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

Копирует указанный массив, обрезая или заполняя нулями (если необходимо), чтобы копия имела указанную длину. Для всех индексов, которые являются допустимыми как в исходном массиве, так и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не в оригинале, копия будет содержать 0L. Такие индексы будут существовать тогда и только тогда, когда указанная длина больше, чем длина исходного массива.

Параметры:: original - массив, который будет скопирован; newLength - длина возвращаемой копии
Возвращает:: копию исходного массива, обрезав или дополнив нулями, чтобы получить указанную длину
Исключения:: NegativeArraySizeException - если newLength отрицательно; NullPointerException - если original равен null
С:: 1.6

copyOf

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

Копирует указанный массив, обрезая или заполняя нулевыми символами (если необходимо), чтобы копия имела указанную длину. Для всех индексов, которые являются допустимыми как в исходном массиве, так и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не в оригинале, копия будет содержать '\\u000'. Такие индексы будут существовать тогда и только тогда, когда указанная длина больше, чем длина исходного массива.

Параметры:: original - массив, который будет скопирован; newLength - длина возвращаемой копии
Возвращает:: копию исходного массива, обрезав или дополнив нулевыми символами, чтобы получить указанную длину
Исключения:: NegativeArraySizeException - если newLength отрицательно; NullPointerException - если original равен null
С:: 1.6

copyOf

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

Копирует указанный массив, усекая или дополняя нулями (при необходимости), чтобы копия имела указанную длину. Для всех индексов, которые являются допустимыми как в исходном массиве, так и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не в исходном массиве, копия будет содержать 0f. Такие индексы будут существовать только в том случае, если указанная длина больше длины исходного массива.

Параметры:: original - массив, который необходимо скопировать; newLength - длина возвращаемой копии
Возвращает:: копию исходного массива, усеченную или дополненную нулями, чтобы получить указанную длину
Исключение:: NegativeArraySizeException - если newLength отрицательно; NullPointerException - если original равно null
С тех пор:: 1.6

copyOf

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

Копирует указанный массив, усекая или дополняя нулями (при необходимости), чтобы копия имела указанную длину. Для всех индексов, которые являются допустимыми как в исходном массиве, так и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не в исходном массиве, копия будет содержать 0d. Такие индексы будут существовать только в том случае, если указанная длина больше длины исходного массива.

Параметры:: original - массив, который необходимо скопировать; newLength - длина возвращаемой копии
Возвращает:: копию исходного массива, усеченную или дополненную нулями, чтобы получить указанную длину
Исключение:: NegativeArraySizeException - если newLength отрицательно; NullPointerException - если original равно null
С тех пор:: 1.6

copyOf

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

Копирует указанный массив, усекая или дополняя значением false (при необходимости), чтобы копия имела указанную длину. Для всех индексов, которые являются допустимыми как в исходном массиве, так и в копии, два массива будут содержать идентичные значения. Для любых индексов, которые допустимы в копии, но не в исходном массиве, копия будет содержать false. Такие индексы будут существовать только в том случае, если указанная длина больше длины исходного массива.

Параметры:: original - массив, который необходимо скопировать; newLength - длина возвращаемой копии
Возвращает:: копию исходного массива, усеченную или дополненную значениями false для получения указанной длины
Исключение:: NegativeArraySizeException - если newLength отрицательно; NullPointerException - если original равно null
С тех пор:: 1.6

copyOfRange

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

Копирует указанный диапазон из указанного массива в новый массив. Начальный индекс диапазона (from) должен находиться в пределах от нуля до original.length, включительно. Значение по индексу original[from] помещается в начальный элемент копии (если from == original.length или from == to не равно null). Значения из последующих элементов исходного массива помещаются в последующие элементы копии. Конечный индекс диапазона (to), который должен быть больше или равен from, может быть больше original.length, в этом случае null помещается во все элементы копии, индекс которых больше или равен original.length - from. Длина возвращаемого массива будет to - from.

Полученный массив имеет ровно тот же класс, что и исходный массив.

Параметры типов:: T - класс объектов в массиве
Параметры:: original - массив, из которого копируется диапазон; from - начальный индекс копируемого диапазона, включительно; to - конечный индекс копируемого диапазона, исключая его. (Этот индекс может лежать вне массива.)
Возвращает:: новый массив, содержащий указанный диапазон из исходного массива, усеченный или дополненный null для получения необходимой длины
Исключение:: ArrayIndexOutOfBoundsException - если from < 0 или from > original.length; IllegalArgumentException - если from > to; NullPointerException - если original равно null
С тех пор:: 1.6

copyOfRange

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

Параметры типов:: U - класс объектов в исходном массиве; T - класс объектов в возвращаемом массиве
Параметры:: original - массив, из которого копируется диапазон; from - начальный индекс копируемого диапазона, включительно; to - конечный индекс копируемого диапазона, исключая его. (Этот индекс может лежать вне массива.); newType - класс возвращаемой копии
Возвращает:: новый массив, содержащий указанный диапазон из исходного массива, усеченный или дополненный null для получения необходимой длины
Исключение:: ArrayIndexOutOfBoundsException - если from < 0 или from > original.length; IllegalArgumentException - если from > to; NullPointerException - если original равно null; ArrayStoreException - если элемент, скопированный из original, не имеет типа выполнения, который может храниться в массиве класса newType.
С тех пор:: 1.6

copyOfRange

public static byte[] copyOfRange(byte[] original,
                                 int from,
                                 int to)

Копирует указанный диапазон из указанного массива в новый массив. Начальный индекс диапазона (from) должен находиться в пределах от нуля до original.length, включительно. Значение по индексу original[from] помещается в начальный элемент копии (если from == original.length или from == to не равно null). Значения из последующих элементов исходного массива помещаются в последующие элементы копии. Конечный индекс диапазона (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 равно null
С тех пор:: 1.6

copyOfRange

public static short[] copyOfRange(short[] original,
                                  int from,
                                  int to)

Копирует указанный диапазон из указанного массива в новый массив. Начальный индекс диапазона (from) должен находиться в пределах от нуля до original.length, включительно. Значение по индексу original[from] помещается в начальный элемент копии (если from == original.length или from == to не равно null). Значения из последующих элементов исходного массива помещаются в последующие элементы копии. Конечный индекс диапазона (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 равно null
С тех пор:: 1.6

copyOfRange

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

Копирует указанный диапазон из указанного массива в новый массив. Начальный индекс диапазона (from) должен находиться в пределах от нуля до original.length, включительно. Значение по индексу original[from] помещается в начальный элемент копии (если from == original.length или from == to не равно null). Значения из последующих элементов исходного массива помещаются в последующие элементы копии. Конечный индекс диапазона (to), который должен быть больше или равен from, может быть больше original.length, в этом случае 0 помещается во все элементы копии, индекс которых больше или равен original.length - from. Длина возвращаемого массива будет to - from.

Параметры:: original - массив, из которого будет скопирован диапазон; from - начальный индекс копируемого диапазона, включительно; to - конечный индекс копируемого диапазона, исключая его. (Этот индекс может находиться за пределами массива.)
Возвращает:: новый массив, содержащий указанный диапазон из исходного массива, усечённый или дополненный нулями, чтобы получить необходимую длину
Исключения:: ArrayIndexOutOfBoundsException - если from < 0 или from > original.length; IllegalArgumentException - если from > to; NullPointerException - если original равно null
С:: 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, в этом случае в все элементы копии, индекс которых больше или равен original.length - from, помещается 0L. Длина возвращаемого массива будет to - from.

Параметры:: original - массив, из которого будет скопирован диапазон; from - начальный индекс копируемого диапазона, включительно; to - конечный индекс копируемого диапазона, исключая его. (Этот индекс может находиться за пределами массива.)
Возвращает:: новый массив, содержащий указанный диапазон из исходного массива, усечённый или дополненный нулями, чтобы получить необходимую длину
Исключения:: ArrayIndexOutOfBoundsException - если from < 0 или from > original.length; IllegalArgumentException - если from > to; NullPointerException - если original равно null
С:: 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, в этом случае в все элементы копии, индекс которых больше или равен original.length - from, помещается '\\u000'. Длина возвращаемого массива будет to - from.

Параметры:: original - массив, из которого будет скопирован диапазон; from - начальный индекс копируемого диапазона, включительно; to - конечный индекс копируемого диапазона, исключая его. (Этот индекс может находиться за пределами массива.)
Возвращает:: новый массив, содержащий указанный диапазон из исходного массива, усечённый или дополненный нулевыми символами, чтобы получить необходимую длину
Исключения:: ArrayIndexOutOfBoundsException - если from < 0 или from > original.length; IllegalArgumentException - если from > to; NullPointerException - если original равно null
С:: 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, в этом случае в все элементы копии, индекс которых больше или равен original.length - from, помещается 0f. Длина возвращаемого массива будет to - from.

Параметры:: original - массив, из которого будет скопирован диапазон; from - начальный индекс копируемого диапазона, включительно; to - конечный индекс копируемого диапазона, исключая его. (Этот индекс может находиться за пределами массива.)
Возвращает:: новый массив, содержащий указанный диапазон из исходного массива, усечённый или дополненный нулями, чтобы получить необходимую длину
Исключения:: ArrayIndexOutOfBoundsException - если from < 0 или from > original.length; IllegalArgumentException - если from > to; NullPointerException - если original равно null
С:: 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, в этом случае в все элементы копии, индекс которых больше или равен original.length - from, помещается 0d. Длина возвращаемого массива будет to - from.

Параметры:: original - массив, из которого будет скопирован диапазон; from - начальный индекс копируемого диапазона, включительно; to - конечный индекс копируемого диапазона, исключая его. (Этот индекс может находиться за пределами массива.)
Возвращает:: новый массив, содержащий указанный диапазон из исходного массива, усечённый или дополненный нулями, чтобы получить необходимую длину
Исключения:: ArrayIndexOutOfBoundsException - если from < 0 или from > original.length; IllegalArgumentException - если from > to; NullPointerException - если original равно null
С:: 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, в этом случае в все элементы копии, индекс которых больше или равен original.length - from, помещается false. Длина возвращаемого массива будет to - from.

Параметры:: original - массив, из которого будет скопирован диапазон; from - начальный индекс копируемого диапазона, включительно; to - конечный индекс копируемого диапазона, исключая его. (Этот индекс может находиться за пределами массива.)
Возвращает:: новый массив, содержащий указанный диапазон из исходного массива, усечённый или дополненный ложными значениями, чтобы получить необходимую длину
Исключения:: ArrayIndexOutOfBoundsException - если from < 0 или from > original.length; IllegalArgumentException - если from > to; NullPointerException - если original равно null
С:: 1.6

asList

@SafeVarargs
public static <T> List<T> asList(T... a)

Возвращает список фиксированного размера, поддерживаемый указанным массивом. (Изменения в возвращаемом списке отражаются в массиве.) Этот метод служит мостом между API на основе массивов и списков, в сочетании с Collection.toArray(). Возвращаемый список сериализуем и реализует RandomAccess.

Этот метод также обеспечивает удобный способ создания списка фиксированного размера, инициализированного несколькими элементами:

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

Тип параметров:: T - класс объектов в массиве
Параметры:: a - массив, на основе которого будет создан список
Возвращает:: представление списка, основанное на указанном массиве

hashCode

public static int hashCode(long[] a)

Возвращает хэш-код, основанный на содержимом указанного массива. Для любых двух массивов long a и b таких, что Arrays.equals(a, b), также выполняется Arrays.hashCode(a) == Arrays.hashCode(b).

Возвращаемое значение этого метода совпадает с тем, которое было бы получено при вызове метода hashCode на списке List, содержащем последовательность экземпляров Long, представляющих элементы a в том же порядке. Если a равно null, этот метод возвращает 0.

Параметры:: a - массив, для которого необходимо вычислить хэш-код
Возвращает:: хэш-код, основанный на содержимом a
С:: 1.5

hashCode

public static int hashCode(int[] a)

Возвращает хэш-код на основе содержимого указанного массива. Для любых двух непустых int массивов a и b, таких что Arrays.equals(a, b), также верно, что Arrays.hashCode(a) == Arrays.hashCode(b).

Значение, возвращаемое этим методом, совпадает со значением, которое было бы получено при вызове метода hashCode для List, содержащего последовательность экземпляров Integer, представляющих элементы a в том же порядке. Если a является null, этот метод возвращает 0.

Параметры:: a - массив, для которого нужно вычислить хэш-значение
Возвращает:: хэш-код на основе содержимого для a
С версии:: 1.5

hashCode

public static int hashCode(short[] a)

Возвращает хэш-код на основе содержимого указанного массива. Для любых двух short массивов a и b, таких что Arrays.equals(a, b), также верно, что Arrays.hashCode(a) == Arrays.hashCode(b).

Значение, возвращаемое этим методом, совпадает со значением, которое было бы получено при вызове метода hashCode для List, содержащего последовательность экземпляров Short, представляющих элементы a в том же порядке. Если a является null, этот метод возвращает 0.

Параметры:: a - массив, для которого нужно вычислить хэш-значение
Возвращает:: хэш-код на основе содержимого для a
С версии:: 1.5

hashCode

public static int hashCode(char[] a)

Возвращает хэш-код на основе содержимого указанного массива. Для любых двух char массивов a и b, таких что Arrays.equals(a, b), также верно, что Arrays.hashCode(a) == Arrays.hashCode(b).

Значение, возвращаемое этим методом, совпадает со значением, которое было бы получено при вызове метода hashCode для List, содержащего последовательность экземпляров Character, представляющих элементы a в том же порядке. Если a является null, этот метод возвращает 0.

Параметры:: a - массив, для которого нужно вычислить хэш-значение
Возвращает:: хэш-код на основе содержимого для a
С версии:: 1.5

hashCode

public static int hashCode(byte[] a)

Возвращает хэш-код на основе содержимого указанного массива. Для любых двух byte массивов a и b, таких что Arrays.equals(a, b), также верно, что Arrays.hashCode(a) == Arrays.hashCode(b).

Значение, возвращаемое этим методом, совпадает со значением, которое было бы получено при вызове метода hashCode для List, содержащего последовательность экземпляров Byte, представляющих элементы a в том же порядке. Если a является null, этот метод возвращает 0.

Параметры:: a - массив, для которого нужно вычислить хэш-значение
Возвращает:: хэш-код на основе содержимого для a
С версии:: 1.5

hashCode

public static int hashCode(boolean[] a)

Возвращает хэш-код на основе содержимого указанного массива. Для любых двух boolean массивов a и b, таких что Arrays.equals(a, b), также верно, что Arrays.hashCode(a) == Arrays.hashCode(b).

Значение, возвращаемое этим методом, совпадает со значением, которое было бы получено при вызове метода hashCode для List, содержащего последовательность экземпляров Boolean, представляющих элементы a в том же порядке. Если a является null, этот метод возвращает 0.

Параметры:: a - массив, для которого нужно вычислить хэш-значение
Возвращает:: хэш-код на основе содержимого для a
С версии:: 1.5

hashCode

public static int hashCode(float[] a)

Возвращает хэш-код на основе содержимого указанного массива. Для любых двух float массивов a и b, таких что Arrays.equals(a, b), также верно, что Arrays.hashCode(a) == Arrays.hashCode(b).

Значение, возвращаемое этим методом, совпадает со значением, которое было бы получено при вызове метода hashCode для List, содержащего последовательность экземпляров Float, представляющих элементы a в том же порядке. Если a является null, этот метод возвращает 0.

Параметры:: a - массив, для которого нужно вычислить хэш-значение
Возвращает:: хэш-код на основе содержимого для a
С версии:: 1.5

hashCode

public static int hashCode(double[] a)

Возвращает хэш-код на основе содержимого указанного массива. Для любых двух double массивов a и b, таких что Arrays.equals(a, b), также верно, что Arrays.hashCode(a) == Arrays.hashCode(b).

Значение, возвращаемое этим методом, совпадает со значением, которое было бы получено при вызове метода hashCode для List, содержащего последовательность экземпляров Double, представляющих элементы a в том же порядке. Если a является null, этот метод возвращает 0.

Параметры:: a - массив, для которого нужно вычислить хэш-значение
Возвращает:: хэш-код на основе содержимого для a
С версии:: 1.5

hashCode

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)

Устанавливает все элементы указанного массива, используя предоставленную функцию-генератор для вычисления каждого элемента.

Если функция-генератор вызывает исключение, оно пересылается вызывающему методу, и массив остаётся в неопределённом состоянии.

Замечание API:

Установка поддиапазона массива с использованием функции-генератора для вычисления каждого элемента может быть записана следующим образом:

IntStream.range(startInclusive, endExclusive)
          .forEach(i -> array[i] = generator.apply(i));

Параметры типа:

T - тип элементов массива

Параметры:

array - массив, который необходимо инициализировать

generator - функция, принимающая индекс и возвращающая желаемое значение для данной позиции

Исключение:

NullPointerException - если генератор равен null

С:

1.8

parallelSetAll

public static <T> void parallelSetAll(T[] array,
                                      IntFunction<? extends T> generator)

Устанавливает все элементы указанного массива параллельно, используя предоставленную функцию-генератор для вычисления каждого элемента.

Если функция-генератор вызывает исключение, необработанное исключение выбрасывается из parallelSetAll и массив остаётся в неопределённом состоянии.

Замечание API:

Установка поддиапазона массива параллельно с использованием функции-генератора для вычисления каждого элемента может быть записана следующим образом:

IntStream.range(startInclusive, endExclusive)
          .parallel()
          .forEach(i -> array[i] = generator.apply(i));

Параметры типа:

T - тип элементов массива

Параметры:

array - массив, который необходимо инициализировать

generator - функция, принимающая индекс и возвращающая желаемое значение для данной позиции

Исключение:

NullPointerException - если генератор равен null

С:

1.8

setAll

public static void setAll(int[] array,
                          IntUnaryOperator generator)

Установите все элементы указанного массива, используя предоставленную функцию-генератор для вычисления каждого элемента.

Если функция-генератор вызывает исключение, оно передается вызывающему методу, а массив остается в неопределенном состоянии.

Примечание API:

IntStream.range(startInclusive, endExclusive)
          .forEach(i -> array[i] = generator.applyAsInt(i));

Параметры:

array - массив, который нужно инициализировать

generator - функция, принимающая индекс и генерирующая нужное значение для этой позиции

Исключения:

NullPointerException - если генератор равен null

С тех пор:

1.8

parallelSetAll

public static void parallelSetAll(int[] array,
                                  IntUnaryOperator generator)

Установите все элементы указанного массива параллельно, используя предоставленную функцию-генератор для вычисления каждого элемента.

Если функция-генератор вызывает исключение, необработанное исключение выбрасывается из parallelSetAll и массив остается в неопределенном состоянии.

Примечание API:

IntStream.range(startInclusive, endExclusive)
          .parallel()
          .forEach(i -> array[i] = generator.applyAsInt(i));

Параметры:

array - массив, который нужно инициализировать

generator - функция, принимающая индекс и генерирующая нужное значение для этой позиции

Исключения:

NullPointerException - если генератор равен null

С тех пор:

1.8

setAll

public static void setAll(long[] array,
                          IntToLongFunction generator)

Примечание API:

IntStream.range(startInclusive, endExclusive)
          .forEach(i -> array[i] = generator.applyAsLong(i));

Параметры:

array - массив, который нужно инициализировать

generator - функция, принимающая индекс и генерирующая нужное значение для этой позиции

Исключения:

NullPointerException - если генератор равен null

С тех пор:

1.8

parallelSetAll

public static void parallelSetAll(long[] array,
                                  IntToLongFunction generator)

Примечание API:

IntStream.range(startInclusive, endExclusive)
          .parallel()
          .forEach(i -> array[i] = generator.applyAsLong(i));

Параметры:

array - массив, который нужно инициализировать

generator - функция, принимающая индекс и генерирующая нужное значение для этой позиции

Исключения:

NullPointerException - если генератор равен null

С тех пор:

1.8

setAll

public static void setAll(double[] array,
                          IntToDoubleFunction generator)

Примечание API:

IntStream.range(startInclusive, endExclusive)
          .forEach(i -> array[i] = generator.applyAsDouble(i));

Параметры:

array - массив, который нужно инициализировать

generator - функция, принимающая индекс и генерирующая нужное значение для этой позиции

Исключения:

NullPointerException - если генератор равен null

С тех пор:

1.8

parallelSetAll

public static void parallelSetAll(double[] array,
                                  IntToDoubleFunction generator)

Примечание API:

IntStream.range(startInclusive, endExclusive)
          .parallel()
          .forEach(i -> array[i] = generator.applyAsDouble(i));

Параметры:

array - массив, который нужно инициализировать

generator - функция, принимающая индекс и генерирующая нужное значение для этой позиции

Исключения:

NullPointerException - если генератор равен null

С тех пор:

1.8

spliterator

public static <T> Spliterator<T> spliterator(T[] array)

Возвращает Spliterator, охватывающий весь указанный массив.

Сплитератор сообщает о Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED и Spliterator.IMMUTABLE.

Параметры типа:: T - тип элементов
Параметры:: array - массив, предполагается, что он не изменяется во время использования
Возвращает:: сплитератор для элементов массива
С тех пор:: 1.8

spliterator

public static <T> Spliterator<T> spliterator(T[] array,
                                             int startInclusive,
                                             int endExclusive)

Возвращает Spliterator, охватывающий указанный диапазон в указанном массиве.

Сплитератор сообщает о Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED и Spliterator.IMMUTABLE.

Параметры типа:: T - тип элементов
Параметры:: array - массив, предполагается, что он не изменяется во время использования; startInclusive - первый индекс для охвата, включительно; endExclusive - индекс, непосредственно следующий за последним индексом для охвата
Возвращает:: сплитератор для элементов массива
Исключения:: ArrayIndexOutOfBoundsException - если startInclusive отрицательный, endExclusive меньше startInclusive, или endExclusive больше размера массива
С тех пор:: 1.8

spliterator

public static Spliterator.OfInt spliterator(int[] array)

Возвращает Spliterator.OfInt, охватывающий весь указанный массив.

Сплитератор сообщает о Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED и Spliterator.IMMUTABLE.

Параметры:: array - массив, предполагается, что он не изменяется во время использования
Возвращает:: сплитератор для элементов массива
С тех пор:: 1.8

spliterator

public static Spliterator.OfInt spliterator(int[] array,
                                            int startInclusive,
                                            int endExclusive)

Возвращает Spliterator.OfInt, охватывающий указанный диапазон в указанном массиве.

Сплитератор сообщает о Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED и Spliterator.IMMUTABLE.

Параметры:: array - массив, предполагается, что он не изменяется во время использования; startInclusive - первый индекс для охвата, включительно; endExclusive - индекс, непосредственно следующий за последним индексом для охвата
Возвращает:: сплитератор для элементов массива
Исключения:: ArrayIndexOutOfBoundsException - если startInclusive отрицательный, endExclusive меньше startInclusive, или endExclusive больше размера массива
С тех пор:: 1.8

spliterator

public static Spliterator.OfLong spliterator(long[] array)

Возвращает Spliterator.OfLong, охватывающий весь указанный массив.

Сплитератор сообщает о Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED и Spliterator.IMMUTABLE.

Параметры:: array - массив, предполагается, что он не изменяется во время использования
Возвращает:: сплитератор для элементов массива
С тех пор:: 1.8

spliterator

public static Spliterator.OfLong spliterator(long[] array,
                                             int startInclusive,
                                             int endExclusive)

Возвращает Spliterator.OfLong, охватывающий указанный диапазон в указанном массиве.

Сплитератор сообщает о Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED и Spliterator.IMMUTABLE.

Параметры:: array - массив, предполагается, что он не изменяется во время использования; startInclusive - первый индекс для охвата, включительно; endExclusive - индекс, непосредственно следующий за последним индексом для охвата
Возвращает:: сплитератор для элементов массива
Исключения:: ArrayIndexOutOfBoundsException - если startInclusive отрицательный, endExclusive меньше startInclusive, или endExclusive больше размера массива
С тех пор:: 1.8

spliterator

public static Spliterator.OfDouble spliterator(double[] array)

Возвращает Spliterator.OfDouble, охватывающий весь указанный массив.

Сплитератор сообщает о Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED и Spliterator.IMMUTABLE.

Параметры:: array - массив, предполагается, что он не изменяется во время использования
Возвращает:: сплитератор для элементов массива
С тех пор:: 1.8

spliterator

public static Spliterator.OfDouble spliterator(double[] array,
                                               int startInclusive,
                                               int endExclusive)

Возвращает Spliterator.OfDouble, охватывающий указанный диапазон заданного массива.

Spliterator сообщает о Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED и Spliterator.IMMUTABLE.

Параметры:: array - массив, предполагается, что он не изменяется во время использования; startInclusive - индекс первого элемента для охвата, включительно; endExclusive - индекс, следующий непосредственно за последним индексом для охвата
Возвращает:: Spliterator для элементов массива
Исключения:: ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше startInclusive, или endExclusive больше размера массива
С тех пор:: 1.8

stream

public static <T> Stream<T> stream(T[] array)

Возвращает последовательный Stream с указанным массивом в качестве источника.

Параметры типа:: T - Тип элементов массива
Параметры:: array - Массив, предполагается, что он не изменяется во время использования
Возвращает:: Stream для массива
С тех пор:: 1.8

stream

public static <T> Stream<T> stream(T[] array,
                                   int startInclusive,
                                   int endExclusive)

Возвращает последовательный Stream с указанным диапазоном заданного массива в качестве источника.

Параметры типа:: T - тип элементов массива
Параметры:: array - массив, предполагается, что он не изменяется во время использования; startInclusive - индекс первого элемента для охвата, включительно; endExclusive - индекс, следующий непосредственно за последним индексом для охвата
Возвращает:: Stream для диапазона массива
Исключения:: ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше startInclusive, или endExclusive больше размера массива
С тех пор:: 1.8

stream

public static IntStream stream(int[] array)

Возвращает последовательный IntStream с указанным массивом в качестве источника.

Параметры:: array - массив, предполагается, что он не изменяется во время использования
Возвращает:: IntStream для массива
С тех пор:: 1.8

stream

public static IntStream stream(int[] array,
                               int startInclusive,
                               int endExclusive)

Возвращает последовательный IntStream с указанным диапазоном заданного массива в качестве источника.

Параметры:: array - массив, предполагается, что он не изменяется во время использования; startInclusive - индекс первого элемента для охвата, включительно; endExclusive - индекс, следующий непосредственно за последним индексом для охвата
Возвращает:: IntStream для диапазона массива
Исключения:: ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше startInclusive, или endExclusive больше размера массива
С тех пор:: 1.8

stream

public static LongStream stream(long[] array)

Возвращает последовательный LongStream с указанным массивом в качестве источника.

Параметры:: array - массив, предполагается, что он не изменяется во время использования
Возвращает:: LongStream для массива
С тех пор:: 1.8

stream

public static LongStream stream(long[] array,
                                int startInclusive,
                                int endExclusive)

Возвращает последовательный LongStream с указанным диапазоном заданного массива в качестве источника.

Параметры:: array - массив, предполагается, что он не изменяется во время использования; startInclusive - индекс первого элемента для охвата, включительно; endExclusive - индекс, следующий непосредственно за последним индексом для охвата
Возвращает:: LongStream для диапазона массива
Исключения:: ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше startInclusive, или endExclusive больше размера массива
С тех пор:: 1.8

stream

public static DoubleStream stream(double[] array)

Возвращает последовательный DoubleStream с указанным массивом в качестве источника.

Параметры:: array - массив, предполагается, что он не изменяется во время использования
Возвращает:: DoubleStream для массива
С тех пор:: 1.8

stream

public static DoubleStream stream(double[] array,
                                  int startInclusive,
                                  int endExclusive)

Возвращает последовательный DoubleStream с указанным диапазоном заданного массива в качестве источника.

Параметры:: array - массив, предполагается, что он не изменяется во время использования; startInclusive - индекс первого элемента для охвата, включительно; endExclusive - индекс, следующий непосредственно за последним индексом для охвата
Возвращает:: DoubleStream для диапазона массива
Исключения:: ArrayIndexOutOfBoundsException - если startInclusive отрицательно, endExclusive меньше startInclusive, или endExclusive больше размера массива
С тех пор:: 1.8

compare

public static int compare(boolean[] a,
                          boolean[] b)

Сравнивает два массива boolean лексикографически.

Если два массива имеют общую префиксную часть, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы они были сравнивались с помощью Boolean.compare(boolean, boolean) в индексе внутри соответствующих массивов, который равен длине префикса. В противном случае один массив является правильным префиксом другого, и лексикографическое сравнение является результатом сравнения двух длин массивов. (См. mismatch(boolean[], boolean[]) для определения общего и правильного префикса.)

Ссылка на массив null считается лексикографически меньше, чем ссылка на массив без null. Две ссылки на массивы null считаются равными.

Сравнение согласуется с equals, а точнее, следующее выполняется для массивов a и b:

Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)

Примечание API:

Этот метод ведет себя так, как если бы (для ссылок на массивы без null):

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return Boolean.compare(a[i], b[i]);
     return a.length - b.length;

Параметры:

a - первый сравниваемый массив

b - второй сравниваемый массив

Возвращает:

значение 0 , если первый и второй массивы равны и содержат те же элементы в том же порядке; значение меньше 0 , если первый массив лексикографически меньше второго; и значение больше 0 , если первый массив лексикографически больше второго

С тех пор:

compare

public static int compare(boolean[] a,
                          int aFromIndex,
                          int aToIndex,
                          boolean[] b,
                          int bFromIndex,
                          int bToIndex)

Лексикографически сравнивает два массива boolean в заданных диапазонах.

Если у двух массивов в указанных диапазонах есть общая префиксная часть, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы они были сравнивались с помощью Boolean.compare(boolean, boolean) по относительному индексу в соответствующих массивах, который равен длине префикса. В противном случае один массив является правильным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух диапазонов. (См. mismatch(boolean[], int, int, boolean[], int, int) для определения общего и правильного префикса.)

Сравнение согласуется с equals, точнее, для массивов a и b с заданными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно:

Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
         (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)

Примечание API:

Этот метод ведет себя так:

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return Boolean.compare(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры:

a - первый сравниваемый массив

aFromIndex - индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex - индекс (исключительно) последнего элемента в первом массиве для сравнения

b - второй сравниваемый массив

bFromIndex - индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex - индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

значение 0 , если в указанных диапазонах первый и второй массивы равны и содержат те же элементы в том же порядке; значение меньше 0 , если в указанных диапазонах первый массив лексикографически меньше второго; и значение больше 0 , если в указанных диапазонах первый массив лексикографически больше второго

Исключения:

IllegalArgumentException - если aFromIndex > aToIndex или bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или bFromIndex < 0 or bToIndex > b.length

NullPointerException - если любой массив null

С тех пор:

compare

public static int compare(byte[] a,
                          byte[] b)

Сравнивает два массива byte лексикографически.

Если два массива имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы они сравнивались с помощью Byte.compare(byte, byte) по индексу в соответствующих массивах, который равен длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух массивов. (См. mismatch(byte[], byte[]) для определения общего и собственного префикса.)

Сравнение согласуется с equals, более конкретно, следующее выполняется для массивов a и b:

Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)

Прим. API:

Этот метод ведет себя так, как если бы (для ссылок на массивы без null):

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return Byte.compare(a[i], b[i]);
     return a.length - b.length;

Параметры:

a - первый массив для сравнения

b - второй массив для сравнения

Возвращает:

значение 0, если первый и второй массивы равны и содержат одинаковые элементы в том же порядке; значение меньше 0, если первый массив лексикографически меньше второго массива; и значение больше 0, если первый массив лексикографически больше второго массива

С:

compare

public static int compare(byte[] a,
                          int aFromIndex,
                          int aToIndex,
                          byte[] b,
                          int bFromIndex,
                          int bToIndex)

Сравнивает два массива byte лексикографически в указанных диапазонах.

Если два массива в указанных диапазонах имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы они сравнивались с помощью Byte.compare(byte, byte) по относительному индексу в соответствующих массивах, который равен длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух диапазонов. (См. mismatch(byte[], int, int, byte[], int, int) для определения общего и собственного префикса.)

Сравнение согласуется с equals, более конкретно, следующее выполняется для массивов a и b с указанными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно:

Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
         (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)

Прим. API:

Этот метод ведет себя так:

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return Byte.compare(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры:

a - первый массив для сравнения

aFromIndex - индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex - индекс (исключительно) последнего элемента в первом массиве для сравнения

b - второй массив для сравнения

bFromIndex - индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex - индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

значение 0, если в указанных диапазонах первый и второй массивы равны и содержат одинаковые элементы в том же порядке; значение меньше 0, если в указанных диапазонах первый массив лексикографически меньше второго массива; и значение больше 0, если в указанных диапазонах первый массив лексикографически больше второго массива

Исключения:

IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException - если один из массивов null

С:

compareUnsigned

public static int compareUnsigned(byte[] a,
                                  byte[] b)

Сравнивает два массива byte лексикографически, численно рассматривая элементы как беззнаковые.

Если два массива имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы они сравнивались с помощью Byte.compareUnsigned(byte, byte) по индексу в соответствующих массивах, который равен длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух массивов. (См. mismatch(byte[], byte[]) для определения общего и собственного префикса.)

Прим. API:

Этот метод ведет себя так, как если бы (для ссылок на массивы без null):

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return Byte.compareUnsigned(a[i], b[i]);
     return a.length - b.length;

Параметры:

a - первый массив для сравнения

b - второй массив для сравнения

Возвращает:

С:

compareUnsigned

public static int compareUnsigned(byte[] a,
                                  int aFromIndex,
                                  int aToIndex,
                                  byte[] b,
                                  int bFromIndex,
                                  int bToIndex)

Сравнивает два массива byte лексикографически в указанных диапазонах, численно рассматривая элементы как беззнаковые.

Если два массива в указанных диапазонах имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы они сравнивались с помощью Byte.compareUnsigned(byte, byte) по относительному индексу в соответствующих массивах, который равен длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух диапазонов. (См. mismatch(byte[], int, int, byte[], int, int) для определения общего и собственного префикса.)

Прим. API:

Этот метод ведет себя так:

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return Byte.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры:

a - первый массив для сравнения

aFromIndex - индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex - индекс (исключительно) последнего элемента в первом массиве для сравнения

b - второй массив для сравнения

bFromIndex - индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex - индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

Исключения:

IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException - если один из массивов равен null

С:

compare

public static int compare(short[] a,
                          short[] b)

Сравнивает два массива short лексикографически.

Если два массива имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы они сравнивались с помощью Short.compare(short, short) по индексу в соответствующих массивах, который равен длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух массивов. (См. mismatch(short[], short[]) для определения общего и собственного префикса.)

Сравнение согласуется с equals, более конкретно, следующее выполняется для массивов a и b:

Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)

Прим. API:

Этот метод ведет себя так, как если бы (для ссылок на массивы без null):

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return Short.compare(a[i], b[i]);
     return a.length - b.length;

Параметры:

a - первый массив для сравнения

b - второй массив для сравнения

Возвращает:

С:

compare

public static int compare(short[] a,
                          int aFromIndex,
                          int aToIndex,
                          short[] b,
                          int bFromIndex,
                          int bToIndex)

Сравнивает два массива short лексикографически в указанных диапазонах.

Если два массива в указанных диапазонах имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы они сравнивались с помощью Short.compare(short, short) по относительному индексу в соответствующих массивах, который равен длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух диапазонов. (См. mismatch(short[], int, int, short[], int, int) для определения общего и собственного префикса.)

Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
         (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)

Заметка API:

Этот метод ведет себя так, как будто:

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return Short.compare(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры:

a — первый массив для сравнения

aFromIndex — индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex — индекс (исключительно) последнего элемента в первом массиве для сравнения

b — второй массив для сравнения

bFromIndex — индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex — индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

значение 0, если в указанных диапазонах первый и второй массивы равны и содержат одинаковые элементы в том же порядке; значение меньше 0, если в указанных диапазонах первый массив лексикографически меньше второго; и значение больше 0, если в указанных диапазонах первый массив лексикографически больше второго

Выбрасывает:

IllegalArgumentException — если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException — если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException — если любой из массивов null

С:

compareUnsigned

public static int compareUnsigned(short[] a,
                                  short[] b)

Сравнивает два массива short лексикографически, числовым образом обрабатывая элементы как беззнаковые.

Если два массива имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы по Short.compareUnsigned(short, short), в индексе внутри соответствующих массивов, который равен длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух массивов. (См. mismatch(short[], short[]) для определения общего и собственного префикса.)

Ссылка на массив null считается лексикографически меньше, чем ссылка на не-null массив. Две ссылки на массив null считаются равными.

Заметка API:

Этот метод ведет себя так, как будто (для ссылок на массивы, не являющиеся null):

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return Short.compareUnsigned(a[i], b[i]);
     return a.length - b.length;

Параметры:

a — первый массив для сравнения

b — второй массив для сравнения

Возвращает:

значение 0, если первый и второй массивы равны и содержат одинаковые элементы в том же порядке; значение меньше 0, если первый массив лексикографически меньше второго; и значение больше 0, если первый массив лексикографически больше второго

С:

compareUnsigned

public static int compareUnsigned(short[] a,
                                  int aFromIndex,
                                  int aToIndex,
                                  short[] b,
                                  int bFromIndex,
                                  int bToIndex)

Сравнивает два массива short лексикографически в указанных диапазонах, числовым образом обрабатывая элементы как беззнаковые.

Если два массива в указанных диапазонах имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы по Short.compareUnsigned(short, short), в относительном индексе внутри соответствующих массивов, равном длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух диапазонов. (См. mismatch(short[], int, int, short[], int, int) для определения общего и собственного префикса.)

Заметка API:

Этот метод ведет себя так, как будто:

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return Short.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры:

a — первый массив для сравнения

aFromIndex — индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex — индекс (исключительно) последнего элемента в первом массиве для сравнения

b — второй массив для сравнения

bFromIndex — индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex — индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

значение 0, если в указанных диапазонах первый и второй массивы равны и содержат одинаковые элементы в том же порядке; значение меньше 0, если в указанных диапазонах первый массив лексикографически меньше второго; и значение больше 0, если в указанных диапазонах первый массив лексикографически больше второго

Выбрасывает:

IllegalArgumentException — если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException — если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException — если один из массивов равен null

С:

compare

public static int compare(char[] a,
                          char[] b)

Сравнивает два массива char лексикографически.

Если два массива имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы по Character.compare(char, char), в индексе внутри соответствующих массивов, который равен длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух массивов. (См. mismatch(char[], char[]) для определения общего и собственного префикса.)

Сравнение согласуется с equals, более конкретно для массивов a и b выполняется следующее:

Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)

Заметка API:

Этот метод ведет себя так, как будто (для ссылок на массивы, не являющиеся null):

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return Character.compare(a[i], b[i]);
     return a.length - b.length;

Параметры:

a — первый массив для сравнения

b — второй массив для сравнения

Возвращает:

С:

compare

public static int compare(char[] a,
                          int aFromIndex,
                          int aToIndex,
                          char[] b,
                          int bFromIndex,
                          int bToIndex)

Сравнивает два массива char лексикографически в указанных диапазонах.

Если два массива в указанных диапазонах имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы по Character.compare(char, char), в относительном индексе внутри соответствующих массивов, равном длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух диапазонов. (См. mismatch(char[], int, int, char[], int, int) для определения общего и собственного префикса.)

Сравнение согласуется с equals, более конкретно для массивов a и b с указанными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно:

Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
         (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)

Заметка API:

Этот метод ведет себя так, как будто:

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return Character.compare(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры:

a — первый массив для сравнения

aFromIndex — индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex — индекс (исключительно) последнего элемента в первом массиве для сравнения

b — второй массив для сравнения

bFromIndex — индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex — индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

значение 0, если в указанных диапазонах первый и второй массивы равны и содержат одинаковые элементы в том же порядке; значение меньше 0, если в указанных диапазонах первый массив лексикографически меньше второго; и значение больше 0, если в указанных диапазонах первый массив лексикографически больше второго

Выбрасывает:

IllegalArgumentException — если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException — если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException — если любой из массивов равен null

С:

compare

public static int compare(int[] a,
                          int[] b)

Сравнивает два массива int лексикографически.

Если два массива имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы по Integer.compare(int, int), в индексе внутри соответствующих массивов, который равен длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух массивов. (См. mismatch(int[], int[]) для определения общего и собственного префикса.)

Сравнение согласуется с equals, более конкретно для массивов a и b выполняется следующее:

Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)

Примечание API:

Этот метод ведет себя так, как будто (для ссылок на массивы, отличных от null):

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return Integer.compare(a[i], b[i]);
     return a.length - b.length;

Параметры:

a - первый массив для сравнения

b - второй массив для сравнения

Возвращает:

С момента:

compare

public static int compare(int[] a,
                          int aFromIndex,
                          int aToIndex,
                          int[] b,
                          int bFromIndex,
                          int bToIndex)

Сравнивает два массива int лексикографически в заданных диапазонах.

Если два массива в заданных диапазонах имеют общую префиксную часть, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы это было выполнено с помощью Integer.compare(int, int), в относительном индексе в соответствующих массивах, равном длине префикса. В противном случае один массив является правильным префиксом другого, и лексикографическое сравнение является результатом сравнения двух длин диапазонов. (См. mismatch(int[], int, int, int[], int, int) для определения общей и правильной префиксной части.)

Сравнение согласуется с equals, более конкретно, следующее выполняется для массивов a и b с заданными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно:

Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
         (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)

Примечание API:

Этот метод ведет себя так, как будто:

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return Integer.compare(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры:

a - первый массив для сравнения

aFromIndex - индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex - индекс (исключительно) последнего элемента в первом массиве для сравнения

b - второй массив для сравнения

bFromIndex - индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex - индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

значение 0, если в заданных диапазонах первый и второй массивы равны и содержат одинаковые элементы в том же порядке; значение меньше 0, если в заданных диапазонах первый массив лексикографически меньше второго массива; и значение больше 0, если в заданных диапазонах первый массив лексикографически больше второго массива

Исключения:

IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException - если какой-либо массив null

С момента:

compareUnsigned

public static int compareUnsigned(int[] a,
                                  int[] b)

Сравнивает два массива int лексикографически, рассматривая элементы как беззнаковые.

Если два массива имеют общую префиксную часть, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы это было выполнено с помощью Integer.compareUnsigned(int, int), в индексе в соответствующих массивах, равном длине префикса. В противном случае один массив является правильным префиксом другого, и лексикографическое сравнение является результатом сравнения двух длин массивов. (См. mismatch(int[], int[]) для определения общей и правильной префиксной части.)

Ссылка на массив null считается лексикографически меньше ссылки на массив, отличной от null. Две ссылки на массив null считаются равными.

Примечание API:

Этот метод ведет себя так, как будто (для ссылок на массивы, отличных от null):

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return Integer.compareUnsigned(a[i], b[i]);
     return a.length - b.length;

Параметры:

a - первый массив для сравнения

b - второй массив для сравнения

Возвращает:

С момента:

compareUnsigned

public static int compareUnsigned(int[] a,
                                  int aFromIndex,
                                  int aToIndex,
                                  int[] b,
                                  int bFromIndex,
                                  int bToIndex)

Сравнивает два массива int лексикографически в заданных диапазонах, рассматривая элементы как беззнаковые.

Если два массива в заданных диапазонах имеют общую префиксную часть, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы это было выполнено с помощью Integer.compareUnsigned(int, int), в относительном индексе в соответствующих массивах, равном длине префикса. В противном случае один массив является правильным префиксом другого, и лексикографическое сравнение является результатом сравнения двух длин диапазонов. (См. mismatch(int[], int, int, int[], int, int) для определения общей и правильной префиксной части.)

Примечание API:

Этот метод ведет себя так, как будто:

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return Integer.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры:

a - первый массив для сравнения

aFromIndex - индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex - индекс (исключительно) последнего элемента в первом массиве для сравнения

b - второй массив для сравнения

bFromIndex - индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex - индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

значение 0 если в заданных диапазонах первый и второй массивы равны и содержат одинаковые элементы в том же порядке; значение меньше 0, если в заданных диапазонах первый массив лексикографически меньше второго массива; и значение больше 0, если в заданных диапазонах первый массив лексикографически больше второго массива

Исключения:

IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException - если какой-либо массив равен null

С момента:

compare

public static int compare(long[] a,
                          long[] b)

Сравнивает два массива long лексикографически.

Если два массива имеют общую префиксную часть, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы это было выполнено с помощью Long.compare(long, long), в индексе в соответствующих массивах, равном длине префикса. В противном случае один массив является правильным префиксом другого, и лексикографическое сравнение является результатом сравнения двух длин массивов. (См. mismatch(long[], long[]) для определения общей и правильной префиксной части.)

Сравнение согласуется с equals, более конкретно, следующее выполняется для массивов a и b:

Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)

Примечание API:

Этот метод ведет себя так, как будто (для ссылок на массивы, отличных от null):

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return Long.compare(a[i], b[i]);
     return a.length - b.length;

Параметры:

a - первый массив для сравнения

b - второй массив для сравнения

Возвращает:

С момента:

compare

public static int compare(long[] a,
                          int aFromIndex,
                          int aToIndex,
                          long[] b,
                          int bFromIndex,
                          int bToIndex)

Сравнивает два массива long лексикографически в заданных диапазонах.

Если два массива в заданных диапазонах имеют общую префиксную часть, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы это было выполнено с помощью Long.compare(long, long), в относительном индексе в соответствующих массивах, равном длине префикса. В противном случае один массив является правильным префиксом другого, и лексикографическое сравнение является результатом сравнения двух длин диапазонов. (См. mismatch(long[], int, int, long[], int, int) для определения общей и правильной префиксной части.)

Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
         (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)

Примечание API:

Этот метод ведет себя так, как будто:

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return Long.compare(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры:

a - первый массив для сравнения

aFromIndex - индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex - индекс (исключительно) последнего элемента в первом массиве для сравнения

b - второй массив для сравнения

bFromIndex - индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex - индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

значение 0 если в указанных диапазонах первый и второй массивы равны и содержат одинаковые элементы в том же порядке; значение меньше 0 если в указанных диапазонах первый массив лексикографически меньше второго; и значение больше 0 если в указанных диапазонах первый массив лексикографически больше второго

Исключение:

IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException - если любой из массивов null

С момента:

compareUnsigned

public static int compareUnsigned(long[] a,
                                  long[] b)

Сравнивает два массива long лексикографически, численно обрабатывая элементы как беззнаковые.

Если два массива имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы оно было выполнено с помощью Long.compareUnsigned(long, long), в индексе в соответствующих массивах, равном длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух диапазонов. (См. mismatch(long[], long[]) для определения общего и собственного префикса.)

Ссылка на массив null считается лексикографически меньше ссылки на массив, отличный от null. Две ссылки на массивы null считаются равными.

Примечание API:

Этот метод ведет себя так, как будто (для ссылок на массивы, не являющиеся null) :

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return Long.compareUnsigned(a[i], b[i]);
     return a.length - b.length;

Параметры:

a - первый массив для сравнения

b - второй массив для сравнения

Возвращает:

значение 0 если первый и второй массивы равны и содержат одинаковые элементы в том же порядке; значение меньше 0 если первый массив лексикографически меньше второго; и значение больше 0 если первый массив лексикографически больше второго

С момента:

compareUnsigned

public static int compareUnsigned(long[] a,
                                  int aFromIndex,
                                  int aToIndex,
                                  long[] b,
                                  int bFromIndex,
                                  int bToIndex)

Сравнивает два массива long лексикографически в указанных диапазонах, численно обрабатывая элементы как беззнаковые.

Если два массива в указанных диапазонах имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы оно было выполнено с помощью Long.compareUnsigned(long, long), в относительном индексе в соответствующих массивах, равном длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух диапазонов. (См. mismatch(long[], int, int, long[], int, int) для определения общего и собственного префикса.)

Примечание API:

Этот метод ведет себя так, как будто:

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return Long.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры:

a - первый массив для сравнения

aFromIndex - индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex - индекс (исключительно) последнего элемента в первом массиве для сравнения

b - второй массив для сравнения

bFromIndex - индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex - индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

Исключение:

IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException - если любой из массивов равен null

С момента:

compare

public static int compare(float[] a,
                          float[] b)

Сравнивает два массива float лексикографически.

Если два массива имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы оно было выполнено с помощью Float.compare(float, float), в индексе в соответствующих массивах, равном длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух массивов. (См. mismatch(float[], float[]) для определения общего и собственного префикса.)

Сравнение согласуется с equals, более конкретно, для массивов a и b выполняется следующее:

Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)

Примечание API:

Этот метод ведет себя так, как будто (для ссылок на массивы, не являющиеся null) :

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return Float.compare(a[i], b[i]);
     return a.length - b.length;

Параметры:

a - первый массив для сравнения

b - второй массив для сравнения

Возвращает:

С момента:

compare

public static int compare(float[] a,
                          int aFromIndex,
                          int aToIndex,
                          float[] b,
                          int bFromIndex,
                          int bToIndex)

Сравнивает два массива float лексикографически в указанных диапазонах.

Если два массива в указанных диапазонах имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы оно было выполнено с помощью Float.compare(float, float), в относительном индексе в соответствующих массивах, равном длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух диапазонов. (См. mismatch(float[], int, int, float[], int, int) для определения общего и собственного префикса.)

Сравнение согласуется с equals, более конкретно, для массивов a и b с указанными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно:

Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
         (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)

Примечание API:

Этот метод ведет себя так, как будто:

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return Float.compare(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры:

a - первый массив для сравнения

aFromIndex - индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex - индекс (исключительно) последнего элемента в первом массиве для сравнения

b - второй массив для сравнения

bFromIndex - индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex - индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

Исключение:

IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException - если любой из массивов равен null

С момента:

compare

public static int compare(double[] a,
                          double[] b)

Сравнивает два массива double лексикографически.

Если два массива имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы оно было выполнено с помощью Double.compare(double, double), в индексе в соответствующих массивах, равном длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух массивов. (См. mismatch(double[], double[]) для определения общего и собственного префикса.)

Сравнение согласуется с equals, более конкретно, для массивов a и b выполняется следующее:

Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)

Примечание API:

Этот метод ведет себя так, как если бы (для ссылок на массивы, не являющиеся null):

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return Double.compare(a[i], b[i]);
     return a.length - b.length;

Параметры:

a - первый массив для сравнения

b - второй массив для сравнения

Возвращает:

значение 0, если первый и второй массивы равны и содержат одни и те же элементы в том же порядке; значение меньше 0, если первый массив лексикографически меньше второго массива; и значение больше 0, если первый массив лексикографически больше второго массива

С версии:

compare

public static int compare(double[] a,
                          int aFromIndex,
                          int aToIndex,
                          double[] b,
                          int bFromIndex,
                          int bToIndex)

Сравнивает два double массива лексикографически в заданных диапазонах.

Если два массива в заданных диапазонах имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов, как если бы они были сравнены с помощью Double.compare(double, double) в относительном индексе внутри соответствующих массивов, равном длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух диапазонов. (См. mismatch(double[], int, int, double[], int, int) для определения общего и собственного префикса.)

Сравнение согласуется с equals, точнее, для массивов a и b с указанными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно:

Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
         (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)

Примечание API:

Этот метод ведет себя так, как если бы:

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return Double.compare(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры:

a - первый массив для сравнения

aFromIndex - индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex - индекс (исключительно) последнего элемента в первом массиве для сравнения

b - второй массив для сравнения

bFromIndex - индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex - индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

значение 0, если в заданных диапазонах первый и второй массивы равны и содержат одни и те же элементы в том же порядке; значение меньше 0, если в заданных диапазонах первый массив лексикографически меньше второго; и значение больше 0, если в заданных диапазонах первый массив лексикографически больше второго

Исключение:

IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException - если любой из массивов null

С версии:

compare

public static <T extends Comparable<? super T>> int compare(T[] a,
                                                            T[] b)

Сравнивает два Object массива, содержащих элементы типа Comparable, лексикографически.

Если два массива имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов типа T с индексом i в соответствующих массивах, равным длине префикса, как если бы они были сравнены с помощью:

Comparator.nullsFirst(Comparator.<T>naturalOrder()).
         compare(a[i], b[i])

В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух массивов. (См. mismatch(Object[], Object[]) для определения общего и собственного префикса.)

Ссылка на массив null считается лексикографически меньше, чем ссылка на массив, не являющийся null Ссылки на два null массива считаются равными.

Элемент массива null считается лексикографически меньше, чем элемент массива, не являющийся null. Два элемента массива null считаются равными.

Сравнение согласуется с equals, точнее, для массивов a и b:

Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)

Примечание API:

Этот метод ведет себя так, как если бы (для ссылок на массивы и элементы, не являющиеся null):

int i = Arrays.mismatch(a, b);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return a[i].compareTo(b[i]);
     return a.length - b.length;

Параметры типа:

T - тип элементов сравниваемых массивов

Параметры:

a - первый массив для сравнения

b - второй массив для сравнения

Возвращает:

С версии:

compare

public static <T extends Comparable<? super T>> int compare(T[] a,
                                                            int aFromIndex,
                                                            int aToIndex,
                                                            T[] b,
                                                            int bFromIndex,
                                                            int bToIndex)

Сравнивает два Object массива лексикографически в заданных диапазонах.

Если два массива в заданных диапазонах имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов типа T с относительным индексом i в соответствующих массивах, равным длине префикса, как если бы они были сравнены с помощью:

Comparator.nullsFirst(Comparator.<T>naturalOrder()).
         compare(a[aFromIndex + i, b[bFromIndex + i])

В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух диапазонов. (См. mismatch(Object[], int, int, Object[], int, int) для определения общего и собственного префикса.)

Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
         (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)

Примечание API:

Этот метод ведет себя так, как если бы (для элементов массивов, не являющихся null):

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return a[aFromIndex + i].compareTo(b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры типа:

T - тип элементов сравниваемых массивов

Параметры:

a - первый массив для сравнения

aFromIndex - индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex - индекс (исключительно) последнего элемента в первом массиве для сравнения

b - второй массив для сравнения

bFromIndex - индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex - индекс (исключительно) последнего элемента во втором массиве для сравнения

Возвращает:

Исключение:

IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException - если любой из массивов null

С версии:

compare

public static <T> int compare(T[] a,
                              T[] b,
                              Comparator<? super T> cmp)

Сравнивает два Object массива лексикографически с использованием заданного компаратора.

Если два массива имеют общий префикс, то лексикографическое сравнение является результатом сравнения с заданным компаратором двух элементов в индексе внутри соответствующих массивов, равном длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух массивов. (См. mismatch(Object[], Object[]) для определения общего и собственного префикса.)

Ссылка на массив null считается лексикографически меньше ссылки на массив, не являющийся null Два null массива считаются равными.

Примечание API:

Этот метод ведет себя так, как если бы (для ссылок на массивы, не являющиеся null):

int i = Arrays.mismatch(a, b, cmp);
     if (i >= 0 && i < Math.min(a.length, b.length))
         return cmp.compare(a[i], b[i]);
     return a.length - b.length;

Параметры типа:

T - тип элементов массива

Параметры:

a - первый массив для сравнения

b - второй массив для сравнения

cmp - компаратор для сравнения элементов массива

Возвращает:

значение 0, если первый и второй массивы равны и содержат одни и те же элементы в том же порядке; значение меньше 0, если первый массив лексикографически меньше второго; и значение больше 0, если первый массив лексикографически больше второго

Исключение:

NullPointerException - если компаратор null

С версии:

compare

public static <T> int compare(T[] a,
                              int aFromIndex,
                              int aToIndex,
                              T[] b,
                              int bFromIndex,
                              int bToIndex,
                              Comparator<? super T> cmp)

Сравнивает два Object массива лексикографически в заданных диапазонах.

Если два массива в заданных диапазонах имеют общий префикс, то лексикографическое сравнение является результатом сравнения с заданным компаратором двух элементов в относительном индексе внутри соответствующих массивов, равном длине префикса. В противном случае один массив является собственным префиксом другого, и лексикографическое сравнение является результатом сравнения длин двух диапазонов. (См. mismatch(Object[], int, int, Object[], int, int) для определения общего и собственного префикса.)

Примечание API:

Этот метод ведет себя так, как будто (для элементов, не являющихся массивом):

int i = Arrays.mismatch(a, aFromIndex, aToIndex,
                             b, bFromIndex, bToIndex, cmp);
     if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
         return cmp.compare(a[aFromIndex + i], b[bFromIndex + i]);
     return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);

Параметры типа:

T - тип элементов массива

Параметры:

a - первый массив для сравнения

aFromIndex - индекс (включительно) первого элемента в первом массиве для сравнения

aToIndex - индекс (исключительно) последнего элемента в первом массиве для сравнения

b - второй массив для сравнения

bFromIndex - индекс (включительно) первого элемента во втором массиве для сравнения

bToIndex - индекс (исключительно) последнего элемента во втором массиве для сравнения

cmp - компаратор для сравнения элементов массива

Возвращает:

значение 0 если, в указанных диапазонах, первый и второй массивы равны и содержат одинаковые элементы в том же порядке; значение меньше 0 если, в указанных диапазонах, первый массив лексикографически меньше второго массива; и значение больше 0 если, в указанных диапазонах, первый массив лексикографически больше второго массива

Выбрасывает:

IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex

ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length

NullPointerException - если любой из массивов или компаратор null

С:

mismatch

public static int mismatch(boolean[] a,
                           boolean[] b)

Находит и возвращает индекс первого несовпадения между двумя массивами boolean, иначе возвращает -1, если несовпадения нет. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего массива.

Если два массива имеют общую префиксную часть, то возвращаемый индекс равен длине этой общей префиксной части, и это означает, что несовпадение произошло между двумя элементами в этих индексах в соответствующих массивах. Если один массив является правильным префиксом другого, то возвращаемый индекс равен длине меньшего массива, и это означает, что индекс действителен только для большего массива. В противном случае несовпадения нет.

Два не-null массива, a и b, имеют общую префиксную часть длины pl если следующее выражение истинно:

pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     a[pl] != b[pl]

Обратите внимание, что общая длина префикса 0 указывает на то, что первые элементы из каждого массива не совпадают.

Два не-null массива, a и b, имеют общую правильную префиксную часть, если следующее выражение истинно:

a.length != b.length &&
     Arrays.equals(a, 0, Math.min(a.length, b.length),
                   b, 0, Math.min(a.length, b.length))

Параметры:: a - первый массив, проверяемый на несовпадение; b - второй массив, проверяемый на несовпадение
Возвращает:: индекс первого несовпадения между двумя массивами, в противном случае -1.
Выбрасывает:: NullPointerException - если любой из массивов null
С:: 9

mismatch

public static int mismatch(boolean[] a,
                           int aFromIndex,
                           int aToIndex,
                           boolean[] b,
                           int bFromIndex,
                           int bToIndex)

Находит и возвращает относительный индекс первого несовпадения между двумя массивами boolean в указанных диапазонах, иначе возвращает -1, если несовпадения нет. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего диапазона.

Если два массива в указанных диапазонах имеют общую префиксную часть, то возвращаемый относительный индекс равен длине этой общей префиксной части, и это означает, что несовпадение произошло между двумя элементами в этом относительном индексе в соответствующих массивах. Если один массив является правильным префиксом другого в указанных диапазонах, то возвращаемый относительный индекс равен длине меньшего диапазона, и это означает, что относительный индекс действителен только для массива с более широким диапазоном. В противном случае несовпадения нет.

Два не-null массива, a и b с указанными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно, имеют общую префиксную часть длины pl если следующее выражение истинно:

pl >= 0 &&
     pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
     Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
     a[aFromIndex + pl] != b[bFromIndex + pl]

Два не-null массива, a и b с указанными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно, имеют общую правильную префиксную часть, если следующее выражение истинно:

(aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
     Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                   b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))

Параметры:: a - первый массив, проверяемый на несовпадение; aFromIndex - индекс (включительно) первого элемента в первом массиве для проверки; aToIndex - индекс (исключительно) последнего элемента в первом массиве для проверки; b - второй массив, проверяемый на несовпадение; bFromIndex - индекс (включительно) первого элемента во втором массиве для проверки; bToIndex - индекс (исключительно) последнего элемента во втором массиве для проверки
Возвращает:: относительный индекс первого несовпадения между двумя массивами в указанных диапазонах, в противном случае -1.
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С:: 9

mismatch

public static int mismatch(byte[] a,
                           byte[] b)

Находит и возвращает индекс первого несовпадения между двумя массивами byte, иначе возвращает -1, если несовпадения нет. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего массива.

Два не-null массива, a и b, имеют общую префиксную часть длины pl если следующее выражение истинно:

pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     a[pl] != b[pl]

Два не-null массива, a и b, имеют общую правильную префиксную часть, если следующее выражение истинно:

a.length != b.length &&
     Arrays.equals(a, 0, Math.min(a.length, b.length),
                   b, 0, Math.min(a.length, b.length))

Параметры:: a - первый массив, проверяемый на несовпадение; b - второй массив, проверяемый на несовпадение
Возвращает:: индекс первого несовпадения между двумя массивами, в противном случае -1.
Выбрасывает:: NullPointerException - если любой из массивов null
С:: 9

mismatch

public static int mismatch(byte[] a,
                           int aFromIndex,
                           int aToIndex,
                           byte[] b,
                           int bFromIndex,
                           int bToIndex)

Находит и возвращает относительный индекс первого несовпадения между двумя массивами byte в указанных диапазонах, иначе возвращает -1, если несовпадения нет. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего диапазона.

pl >= 0 &&
     pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
     Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
     a[aFromIndex + pl] != b[bFromIndex + pl]

(aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
     Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                   b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))

Параметры:: a - первый массив, проверяемый на несовпадение; aFromIndex - индекс (включительно) первого элемента в первом массиве для проверки; aToIndex - индекс (исключительно) последнего элемента в первом массиве для проверки; b - второй массив, проверяемый на несовпадение; bFromIndex - индекс (включительно) первого элемента во втором массиве для проверки; bToIndex - индекс (исключительно) последнего элемента во втором массиве для проверки
Возвращает:: относительный индекс первого несовпадения между двумя массивами в указанных диапазонах, в противном случае -1.
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С:: 9

mismatch

public static int mismatch(char[] a,
                           char[] b)

Находит и возвращает индекс первого несовпадения между двумя массивами char, в противном случае возвращает -1, если несовпадение не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего массива.

Если два массива имеют общую префиксную часть, то возвращаемый индекс равен длине общей префиксной части, и следует, что несовпадение существует между двумя элементами в указанном индексе в соответствующих массивах. Если один массив является правильным префиксом другого, то возвращаемый индекс равен длине меньшего массива, и следует, что индекс действителен только для большего массива. В противном случае несовпадения нет.

Два массива a и b без null элементов имеют общую префиксную часть длины pl, если выполняется следующее выражение:

pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     a[pl] != b[pl]

Обратите внимание, что длина общей префиксной части 0 указывает на то, что первые элементы каждого массива не совпадают.

Два массива a и b без null элементов имеют правильный префикс, если выполняется следующее выражение:

a.length != b.length &&
     Arrays.equals(a, 0, Math.min(a.length, b.length),
                   b, 0, Math.min(a.length, b.length))

Параметры:: a - первый массив, который проверяется на несовпадение; b - второй массив, который проверяется на несовпадение
Возвращает:: индекс первого несовпадения между двумя массивами, в противном случае -1.
Выбрасывает:: NullPointerException - если любой из массивов null
С тех пор:: 9

mismatch

public static int mismatch(char[] a,
                           int aFromIndex,
                           int aToIndex,
                           char[] b,
                           int bFromIndex,
                           int bToIndex)

Находит и возвращает относительный индекс первого несовпадения между двумя массивами char в указанных диапазонах, в противном случае возвращает -1, если несовпадение не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего диапазона.

Если два массива в указанных диапазонах имеют общую префиксную часть, то возвращаемый относительный индекс равен длине общей префиксной части, и следует, что несовпадение существует между двумя элементами в указанном относительном индексе в соответствующих массивах. Если один массив является правильным префиксом другого в указанных диапазонах, то возвращаемый относительный индекс равен длине меньшего диапазона, и следует, что относительный индекс действителен только для массива с большим диапазоном. В противном случае несовпадения нет.

Два массива a и b без null элементов с указанными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно имеют общую префиксную часть длины pl, если выполняется следующее выражение:

pl >= 0 &&
     pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
     Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
     a[aFromIndex + pl] != b[bFromIndex + pl]

Два массива a и b без null элементов с указанными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно имеют правильный префикс, если выполняется следующее выражение:

(aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
     Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                   b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))

Параметры:: a - первый массив, который проверяется на несовпадение; aFromIndex - индекс (включительно) первого элемента в первом массиве для проверки; aToIndex - индекс (исключительно) последнего элемента в первом массиве для проверки; b - второй массив, который проверяется на несовпадение; bFromIndex - индекс (включительно) первого элемента во втором массиве для проверки; bToIndex - индекс (исключительно) последнего элемента во втором массиве для проверки
Возвращает:: относительный индекс первого несовпадения между двумя массивами в указанных диапазонах, в противном случае -1.
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С тех пор:: 9

mismatch

public static int mismatch(short[] a,
                           short[] b)

Находит и возвращает индекс первого несовпадения между двумя массивами short , в противном случае возвращает -1, если несовпадение не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего массива.

pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     a[pl] != b[pl]

Два массива a и b без null элементов имеют правильный префикс, если выполняется следующее выражение:

a.length != b.length &&
     Arrays.equals(a, 0, Math.min(a.length, b.length),
                   b, 0, Math.min(a.length, b.length))

Параметры:: a - первый массив, который проверяется на несовпадение; b - второй массив, который проверяется на несовпадение
Возвращает:: индекс первого несовпадения между двумя массивами, в противном случае -1.
Выбрасывает:: NullPointerException - если любой из массивов null
С тех пор:: 9

mismatch

public static int mismatch(short[] a,
                           int aFromIndex,
                           int aToIndex,
                           short[] b,
                           int bFromIndex,
                           int bToIndex)

Находит и возвращает относительный индекс первого несовпадения между двумя массивами short в указанных диапазонах, в противном случае возвращает -1, если несовпадение не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего диапазона.

pl >= 0 &&
     pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
     Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
     a[aFromIndex + pl] != b[bFromIndex + pl]

(aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
     Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                   b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))

Параметры:: a - первый массив, который проверяется на несовпадение; aFromIndex - индекс (включительно) первого элемента в первом массиве для проверки; aToIndex - индекс (исключительно) последнего элемента в первом массиве для проверки; b - второй массив, который проверяется на несовпадение; bFromIndex - индекс (включительно) первого элемента во втором массиве для проверки; bToIndex - индекс (исключительно) последнего элемента во втором массиве для проверки
Возвращает:: относительный индекс первого несовпадения между двумя массивами в указанных диапазонах, в противном случае -1.
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С тех пор:: 9

mismatch

public static int mismatch(int[] a,
                           int[] b)

Находит и возвращает индекс первого несовпадения между двумя массивами int , в противном случае возвращает -1, если несовпадение не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего массива.

pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     a[pl] != b[pl]

Два массива a и b без null элементов имеют правильный префикс, если выполняется следующее выражение:

a.length != b.length &&
     Arrays.equals(a, 0, Math.min(a.length, b.length),
                   b, 0, Math.min(a.length, b.length))

Параметры:: a - первый массив, который проверяется на несовпадение; b - второй массив, который проверяется на несовпадение
Возвращает:: индекс первого несовпадения между двумя массивами, в противном случае -1.
Выбрасывает:: NullPointerException - если любой из массивов null
С тех пор:: 9

mismatch

public static int mismatch(int[] a,
                           int aFromIndex,
                           int aToIndex,
                           int[] b,
                           int bFromIndex,
                           int bToIndex)

Находит и возвращает относительный индекс первого расхождения между двумя массивами int в заданных диапазонах, в противном случае возвращает -1, если расхождение не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего диапазона.

Если два массива в заданных диапазонах имеют общую префиксную часть, то возвращаемый относительный индекс равен длине этой общей префиксной части, и это означает, что расхождение между двумя элементами в соответствующих массивах происходит именно на этом относительном индексе. Если один массив является правильным префиксом другого в заданных диапазонах, то возвращаемый относительный индекс равен длине меньшего диапазона, и это означает, что относительный индекс валиден только для массива с большим диапазоном. В противном случае расхождения нет.

Два не-null массива, a и b с заданными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно, имеют общую префиксную часть длины pl, если выполняется следующее выражение:

pl >= 0 &&
     pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
     Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
     a[aFromIndex + pl] != b[bFromIndex + pl]

Два не-null массива, a и b с заданными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно, имеют правильный префикс, если выполняется следующее выражение:

(aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
     Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                   b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))

Параметры:: a - первый массив, проверяемый на расхождение; aFromIndex - индекс (включительно) первого элемента в первом массиве, проверяемом на расхождение; aToIndex - индекс (исключительно) последнего элемента в первом массиве, проверяемом на расхождение; b - второй массив, проверяемый на расхождение; bFromIndex - индекс (включительно) первого элемента во втором массиве, проверяемом на расхождение; bToIndex - индекс (исключительно) последнего элемента во втором массиве, проверяемом на расхождение
Возвращает:: относительный индекс первого расхождения между двумя массивами в заданных диапазонах, в противном случае -1.
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С:: 9

mismatch

public static int mismatch(long[] a,
                           long[] b)

Находит и возвращает индекс первого расхождения между двумя массивами long, в противном случае возвращает -1, если расхождение не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего массива.

Если два массива имеют общую префиксную часть, то возвращаемый индекс равен длине этой общей префиксной части, и это означает, что расхождение между двумя элементами в соответствующих массивах происходит именно на этом индексе. Если один массив является правильным префиксом другого, то возвращаемый индекс равен длине меньшего массива, и это означает, что индекс валиден только для большего массива. В противном случае расхождения нет.

Два не-null массива, a и b, имеют общую префиксную часть длины pl, если выполняется следующее выражение:

pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     a[pl] != b[pl]

Два не-null массива, a и b, имеют правильный префикс, если выполняется следующее выражение:

a.length != b.length &&
     Arrays.equals(a, 0, Math.min(a.length, b.length),
                   b, 0, Math.min(a.length, b.length))

Параметры:: a - первый массив, проверяемый на расхождение; b - второй массив, проверяемый на расхождение
Возвращает:: индекс первого расхождения между двумя массивами, в противном случае -1.
Выбрасывает:: NullPointerException - если любой из массивов null
С:: 9

mismatch

public static int mismatch(long[] a,
                           int aFromIndex,
                           int aToIndex,
                           long[] b,
                           int bFromIndex,
                           int bToIndex)

Находит и возвращает относительный индекс первого расхождения между двумя массивами long в заданных диапазонах, в противном случае возвращает -1, если расхождение не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего диапазона.

pl >= 0 &&
     pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
     Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
     a[aFromIndex + pl] != b[bFromIndex + pl]

(aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
     Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                   b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))

Параметры:: a - первый массив, проверяемый на расхождение; aFromIndex - индекс (включительно) первого элемента в первом массиве, проверяемом на расхождение; aToIndex - индекс (исключительно) последнего элемента в первом массиве, проверяемом на расхождение; b - второй массив, проверяемый на расхождение; bFromIndex - индекс (включительно) первого элемента во втором массиве, проверяемом на расхождение; bToIndex - индекс (исключительно) последнего элемента во втором массиве, проверяемом на расхождение
Возвращает:: относительный индекс первого расхождения между двумя массивами в заданных диапазонах, в противном случае -1.
Выбрасывает:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С:: 9

mismatch

public static int mismatch(float[] a,
                           float[] b)

Находит и возвращает индекс первого расхождения между двумя массивами float, в противном случае возвращает -1, если расхождение не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего массива.

Два не-null массива, a и b, имеют общую префиксную часть длины pl, если выполняется следующее выражение:

pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     Float.compare(a[pl], b[pl]) != 0

Два не-null массива, a и b, имеют правильный префикс, если выполняется следующее выражение:

a.length != b.length &&
     Arrays.equals(a, 0, Math.min(a.length, b.length),
                   b, 0, Math.min(a.length, b.length))

Параметры:: a - первый массив, проверяемый на расхождение; b - второй массив, проверяемый на расхождение
Возвращает:: индекс первого расхождения между двумя массивами, в противном случае -1.
Выбрасывает:: NullPointerException - если любой из массивов null
С:: 9

mismatch

public static int mismatch(float[] a,
                           int aFromIndex,
                           int aToIndex,
                           float[] b,
                           int bFromIndex,
                           int bToIndex)

Находит и возвращает относительный индекс первого расхождения между двумя массивами float в заданных диапазонах, в противном случае возвращает -1, если расхождение не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего диапазона.

pl >= 0 &&
     pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
     Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
     Float.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0

(aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
     Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                   b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))

Параметры:: a - первый массив, который проверяется на несовпадение; aFromIndex - индекс (включительно) первого элемента в первом массиве, который проверяется; aToIndex - индекс (исключительно) последнего элемента в первом массиве, который проверяется; b - второй массив, который проверяется на несовпадение; bFromIndex - индекс (включительно) первого элемента во втором массиве, который проверяется; bToIndex - индекс (исключительно) последнего элемента во втором массиве, который проверяется
Возвращает:: относительный индекс первого несовпадения между двумя массивами в указанных диапазонах, в противном случае -1.
Исключения:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С момента:: 9

mismatch

public static int mismatch(double[] a,
                           double[] b)

Находит и возвращает индекс первого несовпадения между двумя массивами double, в противном случае возвращает -1, если несовпадения не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего массива.

Если два массива имеют общую префиксную часть, то возвращаемый индекс — длина общей префиксной части, и, следовательно, имеется несовпадение между двумя элементами в этих индексах в соответствующих массивах. Если один массив является правильным префиксом другого, то возвращаемый индекс — длина меньшего массива, и, следовательно, индекс действителен только для большего массива. В противном случае несовпадения нет.

Два массива null, a и b, имеют общую префиксную часть длины pl, если истинно следующее выражение:

pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     Double.compare(a[pl], b[pl]) != 0

Два массива null, a и b, имеют правильный префикс, если истинно следующее выражение:

a.length != b.length &&
     Arrays.equals(a, 0, Math.min(a.length, b.length),
                   b, 0, Math.min(a.length, b.length))

Параметры:: a - первый массив, проверяемый на несовпадение; b - второй массив, проверяемый на несовпадение
Возвращает:: индекс первого несовпадения между двумя массивами, в противном случае -1.
Исключения:: NullPointerException - если любой из массивов null
С момента:: 9

mismatch

public static int mismatch(double[] a,
                           int aFromIndex,
                           int aToIndex,
                           double[] b,
                           int bFromIndex,
                           int bToIndex)

Находит и возвращает относительный индекс первого несовпадения между двумя массивами double в указанных диапазонах, в противном случае возвращает -1, если несовпадения не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего диапазона.

Если два массива в указанных диапазонах имеют общую префиксную часть, то возвращаемый относительный индекс — длина общей префиксной части, и, следовательно, имеется несовпадение между двумя элементами в этом относительном индексе в соответствующих массивах. Если один массив является правильным префиксом другого в указанных диапазонах, то возвращаемый относительный индекс — длина меньшего диапазона, и, следовательно, относительный индекс действителен только для массива с более широким диапазоном. В противном случае несовпадения нет.

Два массива null, a и b, с указанными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно, имеют общую префиксную часть длины pl, если истинно следующее выражение:

pl >= 0 &&
     pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
     Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
     Double.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0

Два массива null, a и b, с указанными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно, имеют правильный префикс, если истинно следующее выражение:

(aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
     Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                   b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))

Параметры:: a - первый массив, проверяемый на несовпадение; aFromIndex - индекс (включительно) первого элемента в первом массиве для проверки; aToIndex - индекс (исключительно) последнего элемента в первом массиве для проверки; b - второй массив, проверяемый на несовпадение; bFromIndex - индекс (включительно) первого элемента во втором массиве для проверки; bToIndex - индекс (исключительно) последнего элемента во втором массиве для проверки
Возвращает:: относительный индекс первого несовпадения между двумя массивами в указанных диапазонах, в противном случае -1.
Исключения:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С момента:: 9

mismatch

public static int mismatch(Object[] a,
                           Object[] b)

Находит и возвращает индекс первого несовпадения между двумя массивами Object, в противном случае возвращает -1, если несовпадения не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего массива.

Два массива null, a и b, имеют общую префиксную часть длины pl, если истинно следующее выражение:

pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl) &&
     !Objects.equals(a[pl], b[pl])

Два массива null, a и b, имеют правильный префикс, если истинно следующее выражение:

a.length != b.length &&
     Arrays.equals(a, 0, Math.min(a.length, b.length),
                   b, 0, Math.min(a.length, b.length))

Параметры:: a - первый массив, проверяемый на несовпадение; b - второй массив, проверяемый на несовпадение
Возвращает:: индекс первого несовпадения между двумя массивами, в противном случае -1.
Исключения:: NullPointerException - если любой из массивов null
С момента:: 9

mismatch

public static int mismatch(Object[] a,
                           int aFromIndex,
                           int aToIndex,
                           Object[] b,
                           int bFromIndex,
                           int bToIndex)

Находит и возвращает относительный индекс первого несовпадения между двумя массивами Object в указанных диапазонах, в противном случае возвращает -1, если несовпадения не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего диапазона.

pl >= 0 &&
     pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
     Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
     !Objects.equals(a[aFromIndex + pl], b[bFromIndex + pl])

(aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
     Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                   b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))

Параметры:: a - первый массив, проверяемый на несовпадение; aFromIndex - индекс (включительно) первого элемента в первом массиве для проверки; aToIndex - индекс (исключительно) последнего элемента в первом массиве для проверки; b - второй массив, проверяемый на несовпадение; bFromIndex - индекс (включительно) первого элемента во втором массиве для проверки; bToIndex - индекс (исключительно) последнего элемента во втором массиве для проверки
Возвращает:: относительный индекс первого несовпадения между двумя массивами в указанных диапазонах, в противном случае -1.
Исключения:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если любой из массивов null
С момента:: 9

mismatch

public static <T> int mismatch(T[] a,
                               T[] b,
                               Comparator<? super T> cmp)

Находит и возвращает индекс первого несовпадения между двумя массивами, в противном случае возвращает -1, если несовпадение не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего массива.

Указанный компаратор используется для определения, не равны ли два элемента массива из каждого массива.

Если два массива имеют общую префиксную часть, то возвращаемый индекс — это длина общей префиксной части, и следует, что несовпадение есть между двумя элементами в этом индексе в соответствующих массивах. Если один массив является правильным префиксом другого, то возвращаемый индекс — это длина меньшего массива, и следует, что индекс действителен только для большего массива. В противном случае несовпадения нет.

Два массива, не содержащие null, a и b, имеют общую префиксную часть длины pl, если истинно следующее выражение:

pl >= 0 &&
     pl < Math.min(a.length, b.length) &&
     Arrays.equals(a, 0, pl, b, 0, pl, cmp)
     cmp.compare(a[pl], b[pl]) != 0

Два массива, не содержащие null, a и b, имеют общую правильную префиксную часть, если истинно следующее выражение:

a.length != b.length &&
     Arrays.equals(a, 0, Math.min(a.length, b.length),
                   b, 0, Math.min(a.length, b.length),
                   cmp)

Type Parameters:: T - тип элементов массива
Parameters:: a - первый массив, который нужно проверить на несовпадение; b - второй массив, который нужно проверить на несовпадение; cmp - компаратор для сравнения элементов массива
Returns:: индекс первого несовпадения между двумя массивами, в противном случае -1.
Throws:: NullPointerException - если какой-либо массив или компаратор null
Since:: 9

mismatch

public static <T> int mismatch(T[] a,
                               int aFromIndex,
                               int aToIndex,
                               T[] b,
                               int bFromIndex,
                               int bToIndex,
                               Comparator<? super T> cmp)

Находит и возвращает относительный индекс первого несовпадения между двумя массивами Object в указанных диапазонах, в противном случае возвращает -1, если несовпадение не найдено. Индекс будет в диапазоне от 0 (включительно) до длины (включительно) меньшего диапазона.

Если два массива в указанных диапазонах имеют общую префиксную часть, то возвращаемый относительный индекс — это длина общей префиксной части, и следует, что несовпадение есть между двумя элементами в этом относительном индексе в соответствующих массивах. Если один массив является правильным префиксом другого в указанных диапазонах, то возвращаемый относительный индекс — это длина меньшего диапазона, и следует, что относительный индекс действителен только для массива с большим диапазоном. В противном случае несовпадения нет.

Два массива, не содержащие null, a и b, с указанными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно, имеют общую префиксную часть длины pl, если истинно следующее выражение:

pl >= 0 &&
     pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
     Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl, cmp) &&
     cmp.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0

Два массива, не содержащие null, a и b, с указанными диапазонами [aFromIndex, atoIndex) и [bFromIndex, btoIndex) соответственно, имеют общую правильную префиксную часть, если истинно следующее выражение:

(aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
     Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                   b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                   cmp)

Type Parameters:: T - тип элементов массива
Parameters:: a - первый массив, который нужно проверить на несовпадение; aFromIndex - индекс (включительно) первого элемента в первом массиве, который нужно проверить; aToIndex - индекс (исключительно) последнего элемента в первом массиве, который нужно проверить; b - второй массив, который нужно проверить на несовпадение; bFromIndex - индекс (включительно) первого элемента во втором массиве, который нужно проверить; bToIndex - индекс (исключительно) последнего элемента во втором массиве, который нужно проверить; cmp - компаратор для сравнения элементов массива
Returns:: относительный индекс первого несовпадения между двумя массивами в указанных диапазонах, в противном случае -1.
Throws:: IllegalArgumentException - если aFromIndex > aToIndex или если bFromIndex > bToIndex; ArrayIndexOutOfBoundsException - если aFromIndex < 0 or aToIndex > a.length или если bFromIndex < 0 or bToIndex > b.length; NullPointerException - если какой-либо массив или компаратор null
Since:: 9

© 1993, 2020, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Arrays.html