Класс Arrays

public static void sort(int[] a)

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

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

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

public static void sort(long[] a)

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

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

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

public static void sort(short[] a)

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

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

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

public static void sort(char[] a)

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

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

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

public static void sort(byte[] a)

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

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

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

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 считаются равными.

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

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

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

public static void sort(double[] a)

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

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

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

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

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

public static void parallelSort(byte[] a)

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

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

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

public static void parallelSort(char[] a)

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

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

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

public static void parallelSort(short[] a)

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

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

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

public static void parallelSort(int[] a)

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

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

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

public static void parallelSort(long[] a)

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

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

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

public static void parallelSort(float[] a)

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

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

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

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

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

public static void parallelSort(double[] a)

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

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

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

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

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

public static <T extends Comparable<? super T>> void parallelSort(T[] a)

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

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

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 в массиве).

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

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

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

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

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 в диапазоне).

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

public static void sort(Object[] a)

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

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

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

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

Реализация была адаптирована из сортировки списка Тима Питерса для Python ( TimSort). Она использует методы из статьи Питера МакИлроя "Оптимистичная сортировка и информационно-теоретическая сложность" в Трудах четвертого ежегодного симпозиума ACM-SIAM по дискретным алгоритмам, стр. 467-474, январь 1993 г.

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

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

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

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

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

Реализация была адаптирована из сортировки списка Тима Питерса для Python ( TimSort). Она использует методы из работы Питера МакИлроя "Оптимистичная сортировка и информационно-теоретическая сложность" в Трудах четвертого ежегодного симпозиума ACM-SIAM по дискретным алгоритмам, стр. 467-474, январь 1993 г.

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

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

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

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

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

Реализация была адаптирована из сортировки списка Тима Питерса для Python ( TimSort). Она использует методы из работы Питера МакИлроя "Оптимистичная сортировка и информационно-теоретическая сложность" в Трудах четвертого ежегодного симпозиума ACM-SIAM по дискретным алгоритмам, стр. 467-474, январь 1993 г.

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 в диапазоне).

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

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

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

Реализация была адаптирована из сортировки списка Тима Питерса для Python ( TimSort). Она использует методы из работы Питера МакИлроя "Оптимистичная сортировка и информационно-теоретическая сложность" в Трудах четвертого ежегодного симпозиума ACM-SIAM по дискретным алгоритмам, стр. 467-474, январь 1993 г.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

public static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)

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

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

Выполняет поиск указанного объекта в заданном диапазоне указанного массива с использованием алгоритма бинарного поиска. Диапазон должен быть отсортирован в порядке возрастания в соответствии с указанным компаратором (как с помощью метода sort(T[], int, int, Comparator)) перед вызовом этого метода. Если он не отсортирован, результаты не определены. Если диапазон содержит несколько элементов, равных указанному объекту, нет гарантии, какой из них будет найден.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Double.valueOf(d1).equals(Double.valueOf(d2))

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

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

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

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

Два числа с плавающей точкой двойной точности d1 и d2 считаются равными, если:

    Double.valueOf(d1).equals(Double.valueOf(d2))

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

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

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

    Float.valueOf(f1).equals(Float.valueOf(f2))

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

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

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

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

Два числа с плавающей точкой одинарной точности f1 и f2 считаются равными, если:

    Float.valueOf(f1).equals(Float.valueOf(f2))

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Результирующий массив имеет точно такой же класс, как и исходный массив.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает список фиксированного размера, поддерживаемый указанным массивом. Изменения, внесенные в массив, будут видны в возвращенном списке, и изменения, внесенные в список, будут видны в массиве. Возвращаемый список является Serializable и реализует RandomAccess.

Возвращаемый список реализует необязательные методы Collection, за исключением тех, которые изменяют размер возвращаемого списка. Эти методы не изменяют список и выбрасывают UnsupportedOperationException.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 элементы на любой глубине.

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

public static String toString(long[] a)

Возвращает строковое представление содержимого указанного массива. Строковое представление состоит из списка элементов массива, заключенных в квадратные скобки ("[]"). Смежные элементы разделены символами ", " (запятая с пробелом). Элементы преобразуются в строки как String.valueOf(long). Возвращает "null" если a является null.

public static String toString(int[] a)

Возвращает строковое представление содержимого указанного массива. Строковое представление состоит из списка элементов массива, заключенных в квадратные скобки ("[]"). Смежные элементы разделены символами ", " (запятая с пробелом). Элементы преобразуются в строки как String.valueOf(int). Возвращает "null" если a является null.

public static String toString(short[] a)

Возвращает строковое представление содержимого указанного массива. Строковое представление состоит из списка элементов массива, заключенных в квадратные скобки ("[]"). Смежные элементы разделены символами ", " (запятая с пробелом). Элементы преобразуются в строки как String.valueOf(short). Возвращает "null" если a является null.

public static String toString(char[] a)

Возвращает строковое представление содержимого указанного массива. Строковое представление состоит из списка элементов массива, заключенных в квадратные скобки ("[]"). Смежные элементы разделены символами ", " (запятая с пробелом). Элементы преобразуются в строки как String.valueOf(char). Возвращает "null" если a является null.

public static String toString(byte[] a)

Возвращает строковое представление содержимого указанного массива. Строковое представление состоит из списка элементов массива, заключенных в квадратные скобки ("[]"). Смежные элементы разделены символами ", " (запятая с пробелом). Элементы преобразуются в строки как String.valueOf(byte). Возвращает "null" если a является null.

public static String toString(boolean[] a)

Возвращает строковое представление содержимого указанного массива. Строковое представление состоит из списка элементов массива, заключенных в квадратные скобки ("[]"). Смежные элементы разделены символами ", " (запятая с пробелом). Элементы преобразуются в строки как String.valueOf(boolean). Возвращает "null" если a является null.

public static String toString(float[] a)

Возвращает строковое представление содержимого указанного массива. Строковое представление состоит из списка элементов массива, заключенных в квадратные скобки ("[]"). Смежные элементы разделены символами ", " (запятая с пробелом). Элементы преобразуются в строки как String.valueOf(float). Возвращает "null" если a является null.

public static String toString(double[] a)

Возвращает строковое представление содержимого указанного массива. Строковое представление состоит из списка элементов массива, заключенных в квадратные скобки ("[]"). Смежные элементы разделены символами ", " (запятая с пробелом). Элементы преобразуются в строки как String.valueOf(double). Возвращает "null" если a является null.

public static String toString(Object[] a)

Возвращает строковое представление содержимого указанного массива. Если массив содержит другие массивы в качестве элементов, они преобразуются в строки методом Object.toString(), унаследованным от Object, который описывает их идентификаторы, а не их содержимое.

Значение, возвращаемое этим методом, равно значению, которое было бы возвращено Arrays.asList(a).toString(), если только a не является null, в этом случае возвращается "null".

public static String deepToString(Object[] a)

Возвращает строковое представление «глубокого содержимого» указанного массива. Если массив содержит другие массивы в качестве элементов, строковое представление содержит их содержимое и так далее. Этот метод предназначен для преобразования многомерных массивов в строки.

Строковое представление состоит из списка элементов массива, заключенных в квадратные скобки ("[]"). Смежные элементы разделяются символами ", " (запятая с пробелом). Элементы преобразуются в строки, как и String.valueOf(Object), если только они сами не являются массивами.

Если элемент e является массивом примитивного типа, он преобразуется в строку путем вызова соответствующей перегрузки Arrays.toString(e). Если элемент e является массивом ссылочного типа, он преобразуется в строку путем рекурсивного вызова этого метода.

Чтобы избежать бесконечной рекурсии, если указанный массив содержит сам себя в качестве элемента или содержит косвенную ссылку на себя через один или несколько уровней массивов, самоссылка преобразуется в строку "[...]". Например, массив, содержащий только ссылку на себя, будет отображаться как "[[...]]".

Этот метод возвращает "null", если указанный массив является null.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

public static IntStream stream(int[] array)

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

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

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

public static LongStream stream(long[] array)

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

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

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

public static DoubleStream stream(double[] array)

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

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

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

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)
 

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)
 

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

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

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

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

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

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

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)
 

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

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

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

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

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) для определения общего и собственного префикса.)

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

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

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

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

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

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

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) для определения общего и собственного префикса.)

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

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

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

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

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

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

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) для определения общего и собственного префикса.)

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

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

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

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

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

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

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)
 

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

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

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

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

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

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

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)
 

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

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

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

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

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) для определения общего и собственного префикса.)

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

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

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

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

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

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

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) для определения общего и собственного префикса.)

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

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

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

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

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

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

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) для определения общего и собственного префикса.)

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

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

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

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

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

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

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)
 

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

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

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

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

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

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

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)
 

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

Лексикографически сравнивает два массива Object, внутри сравнимых элементов.

Если два массива имеют общий префикс, то лексикографическое сравнение является результатом сравнения двух элементов типа 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)
 

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) для определения общего и собственного префикса.)

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

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