Класс 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)

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

Отношение < не обеспечивает полного порядка для всех значений float: -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, диапазон для сортировки пуст.

Отношение < не обеспечивает полного порядка для всех значений float: -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)

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

Отношение < не обеспечивает полного порядка для всех значений типа double: -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, то сортируемый диапазон пуст.

Отношение < не обеспечивает полного порядка для всех значений типа double: -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)

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

Отношение < не предоставляет полной упорядоченности для всех значений типа float: -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, диапазон для сортировки пустой.

Отношение < не предоставляет полной упорядоченности для всех значений типа float: -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)

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

Отношение < не предоставляет полной упорядоченности для всех значений типа double: -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 ссылок на объекты для случайно упорядоченных массивов.

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

Реализация была адаптирована из сортировки списков Tim Peters для Python ( TimSort). Она использует методы из работы Peter McIlroy «Optimistic Sorting and Information Theoretic Complexity», Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 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 ссылок на объекты для массивов со случайным порядком.

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

Реализация была адаптирована из сортировки списков Tim Peters для 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 ссылок на объекты для массивов со случайным порядком.

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

Реализация была адаптирована из сортировки списков Tim Peters для 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 ссылок на объекты для массивов со случайным порядком.

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

Реализация была адаптирована из сортировки списков Tim Peters для 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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ищет заданное значение в диапазоне заданного массива double с помощью алгоритма бинарного поиска. Диапазон должен быть отсортирован (как методом 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, если два заданных массива long равны друг другу. Два массива считаются равными, если оба массива содержат одинаковое количество элементов и все соответствующие пары элементов в двух массивах равны. Другими словами, два массива равны, если они содержат одинаковые элементы в том же порядке. Кроме того, две ссылки на массив считаются равными, если обе являются null.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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, если два указанных массива значений типа double равны друг другу. Два массива считаются равными, если оба массива содержат одинаковое количество элементов и все соответствующие пары элементов в двух массивах равны. Другими словами, два массива равны, если они содержат одни и те же элементы в том же порядке. Также две ссылки на массивы считаются равными, если обе являются null. Два значения типа double d1 и d2 считаются равными, если:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 каждому элементу указанного диапазона указанного массива символов. Заполняемый диапазон простирается от индекса fromIndex включительно до индекса toIndex, не включая его. (Если fromIndex==toIndex, заполняемый диапазон пуст.)

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

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

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

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

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

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

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

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

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.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED и Spliterator.IMMUTABLE.

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

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

Разделитель сообщает о Spliterator.SIZED, Spliterator.SUBSIZED, Spliterator.ORDERED и Spliterator.IMMUTABLE.

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

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

Разделитель сообщает о 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)