Методы для работы с массивами: java.util.Arrays

Используем готовые методы для сортировки, поиска, заполнения и сравнения массивов — как набор инструментов для работы с данными

Зачем нужны методы Arrays?

Представьте, что вам нужно построить дом. Вы можете вырезать каждый гвоздь из железа вручную, или пойти в магазин и купить готовые гвозди. Разумеется, вы купите готовые — зачем изобретать велосипед, если кто-то уже сделал это за вас?

То же самое работает в программировании. Зачем писать сортировку массива в 20 строк, если в Java уже есть метод Arrays.sort(), который делает это за одну строку и работает быстрее, чем ваш код? Зачем писать поиск элемента, если есть Arrays.binarySearch()?

Класс java.util.Arrays — это набор статических методов, специально созданных для работы с массивами. Они решают самые частые задачи: сортировка, поиск, сравнение, заполнение, копирование и вывод массивов.

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

import java.util.Arrays;

Все методы в классе Arrays — статические, то есть вызываются через имя класса: Arrays.sort(arr), Arrays.toString(arr) и так далее.

Arrays.toString() — вывод массива в строку

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

import java.util.Arrays;

int[] nums = {5, 3, 8, 1, 9};
String result = Arrays.toString(nums);
System.out.println(result);
// Вывод: [5, 3, 8, 1, 9]

Какие типы массивов поддерживает toString():

import java.util.Arrays;

// Примитивные типы
int[] ints = {1, 2, 3};
double[] doubles = {1.5, 2.5, 3.5};
boolean[] bools = {true, false, true};
char[] chars = {'A', 'B', 'C'};
long[] longs = {100L, 200L, 300L};
byte[] bytes = {10, 20, 30};
short[] shorts = {100, 200};
float[] floats = {1.1f, 2.2f};

System.out.println(Arrays.toString(ints));     // [1, 2, 3]
System.out.println(Arrays.toString(doubles));   // [1.5, 2.5, 3.5]
System.out.println(Arrays.toString(bools));     // [true, false, true]
System.out.println(Arrays.toString(chars));     // [A, B, C]
System.out.println(Arrays.toString(longs));     // [100, 200, 300]
System.out.println(Arrays.toString(bytes));     // [10, 20, 30]
System.out.println(Arrays.toString(shorts));    // [100, 200]
System.out.println(Arrays.toString(floats));    // [1.1, 2.2]

// Ссылочные типы
String[] strings = {"Привет", "Мир"};
System.out.println(Arrays.toString(strings));   // [Привет, Мир]

Метод toString() очень полезен при отладке — он позволяет мгновенно увидеть содержимое массива:

import java.util.Arrays;

int[] data = new int[10];
System.out.println("Пустой массив: " + Arrays.toString(data));
// Вывод: Пустой массив: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

for (int i = 0; i < data.length; i++) {
    data[i] = i * i;
}

System.out.println("Заполненный: " + Arrays.toString(data));
// Вывод: Заполненный: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Arrays.sort() — сортировка массива

Сортировка — это одна из самых важных операций в программировании. Она используется повсюду: от сортировки списка контактов в телефоне до обработки миллионов записей в базе данных. Метод Arrays.sort() сортирует массив «на месте» (in-place), то есть изменяет исходный массив, не создавая новый.

Сортировка чисел

import java.util.Arrays;

int[] numbers = {5, 2, 8, 1, 9, 3};
System.out.println("До: " + Arrays.toString(numbers));

Arrays.sort(numbers);
System.out.println("После: " + Arrays.toString(numbers));
// Вывод:
// До: [5, 2, 8, 1, 9, 3]
// После: [1, 2, 3, 5, 8, 9]

По умолчанию sort() сортирует по возрастанию — от наименьшего к наибольшему. Это работает для всех примитивных типов: int, double, float, long, char и так далее.

Сортировка строк

Строки сортируются в алфавитном порядке (точнее, в порядке Unicode):

import java.util.Arrays;

String[] names = {"Виктор", "Анна", "Галина", "Борис", "Елена"};
System.out.println("До: " + Arrays.toString(names));

Arrays.sort(names);
System.out.println("После: " + Arrays.toString(names));
// Вывод:
// До: [Виктор, Анна, Галина, Борис, Елена]
// После: [Анна, Борис, Виктор, Галина, Елена]

Сортировка строк идёт посимвольно: сначала сравниваются первые символы, если они равны — вторые, и так далее. Заглавные буквы идут перед строчными в таблице Unicode, поэтому 'А' (код 1040) будет перед 'а' (код 1072).

import java.util.Arrays;

String[] words = {"Банан", "Яблоко", "абрикос", "Вишня"};
Arrays.sort(words);
System.out.println(Arrays.toString(words));
// Вывод: [Банан, Вишня, Яблоко, абрикос]
// Заглавные Б, В, Я идут перед строчной а

Сортировка дробных чисел

import java.util.Arrays;

double[] prices = {9.99, 2.50, 5.75, 1.25, 7.50};
Arrays.sort(prices);
System.out.println(Arrays.toString(prices));
// Вывод: [1.25, 2.5, 5.75, 7.5, 9.99]

Обратная сортировка (по убыванию)

Для сортировки по убыванию нужно сначала отсортировать по возрастанию, а затем перевернуть массив:

import java.util.Arrays;

int[] numbers = {5, 2, 8, 1, 9, 3};
Arrays.sort(numbers);

for (int i = 0; i < numbers.length / 2; i++) {
    int temp = numbers[i];
    numbers[i] = numbers[numbers.length - 1 - i];
    numbers[numbers.length - 1 - i] = temp;
}

System.out.println(Arrays.toString(numbers));
// Вывод: [9, 8, 5, 3, 2, 1]

Или более изящно — используя стримы (мы изучим это позже):

import java.util.Arrays;

int[] numbers = {5, 2, 8, 1, 9, 3};
int[] descending = Arrays.stream(numbers)
    .boxed()
    .sorted((a, b) -> b - a)
    .mapToInt(Integer::intValue)
    .toArray();

System.out.println(Arrays.toString(descending));
// Вывод: [9, 8, 5, 3, 2, 1]

Сортировка части массива

Можно отсортировать только часть массива, указав начальный и конечный индексы:

import java.util.Arrays;

int[] arr = {9, 1, 5, 3, 7, 2, 8};
System.out.println("До: " + Arrays.toString(arr));

Arrays.sort(arr, 2, 5);  // сортируем индексы 2, 3, 4
System.out.println("После: " + Arrays.toString(arr));
// Вывод:
// До: [9, 1, 5, 3, 7, 2, 8]
// После: [9, 1, 3, 5, 7, 2, 8]
// Отсортирована только часть [5, 3, 7] → [3, 5, 7]

Arrays.binarySearch() — быстрый поиск

Метод Arrays.binarySearch() ищет элемент в ОТСОРТИРОВАННОМ массиве используя алгоритм бинарного поиска. Он намного быстрее перебора по одному — если перебор проверяет каждый элемент по очереди, то бинарный поиск сразу отсекает половину оставшихся элементов на каждом шаге.

Аналогия: Представьте, что вы ищете слово в словаре. Вы не начинаете с первой страницы и не листаете по одной. Вы открываете середину, смотрите: искомое слово раньше или позже? И сразу переходите в нужную половину. Так работает бинарный поиск — за каждый шаг отсекает половину вариантов.

Метод возвращает индекс найденного элемента, или отрицательное число, если элемент не найден:

import java.util.Arrays;

int[] numbers = {1, 3, 5, 7, 9, 11, 13};

int index = Arrays.binarySearch(numbers, 7);
System.out.println("Индекс 7: " + index);  // 3

int notFound = Arrays.binarySearch(numbers, 6);
System.out.println("Индекс 6: " + notFound);  // -4

Что означает отрицательный результат? Если элемент не найден, метод возвращает -(точка_вставки) - 1. Точка вставки — это индекс, куда нужно было бы вставить элемент, чтобы массив остался отсортированным.

import java.util.Arrays;

int[] arr = {10, 20, 30, 40, 50};

// Поиск существующего элемента
System.out.println(Arrays.binarySearch(arr, 30));  // 2

// Поиск несуществующего элемента
int result = Arrays.binarySearch(arr, 25);
System.out.println(result);  // -3

// Чтобы получить точку вставки:
int insertionPoint = -result - 1;
System.out.println("Точка вставки: " + insertionPoint);  // 2
// Элемент 25 нужно вставить между индексами 1 и 2

Поиск в отсортированном массиве строк

import java.util.Arrays;

String[] names = {"Анна", "Борис", "Виктор", "Галина", "Елена"};

System.out.println(Arrays.binarySearch(names, "Виктор"));  // 2
System.out.println(Arrays.binarySearch(names, "Дмитрий")); // -4
System.out.println(Arrays.binarySearch(names, "Анна"));    // 0

Поиск в части массива

import java.util.Arrays;

int[] arr = {5, 10, 15, 20, 25, 30, 35};

int idx = Arrays.binarySearch(arr, 3, 6, 25);
System.out.println("Индекс: " + idx);  // 5

int notIdx = Arrays.binarySearch(arr, 3, 6, 35);
System.out.println("Не найден: " + notIdx);  // -7

Сравнение скорости: линейный поиск проверяет каждый элемент (O(n)), а бинарный — отсекает половину на каждом шаге (O(log n)). Для массива из 1 миллиона элементов: линейный — до 1 000 000 сравнений, бинарный — до 20!

import java.util.Arrays;

int[] bigArray = new int[1000000];
for (int i = 0; i < bigArray.length; i++) {
    bigArray[i] = i * 2;
}

// Бинарный поиск — мгновенно
long start = System.nanoTime();
Arrays.binarySearch(bigArray, 999998);
long end = System.nanoTime();
System.out.println("Бинарный поиск: " + (end - start) + " нс");

// Линейный поиск — дольше
start = System.nanoTime();
for (int i = 0; i < bigArray.length; i++) {
    if (bigArray[i] == 999998) break;
}
end = System.nanoTime();
System.out.println("Линейный поиск: " + (end - start) + " нс");

Arrays.fill() — заполнение массива

Метод Arrays.fill() заполняет весь массив (или его часть) одним и тем же значением. Это гораздо удобнее, чем писать цикл вручную.

Заполнение всего массива

import java.util.Arrays;

int[] arr = new int[10];
Arrays.fill(arr, 42);
System.out.println(Arrays.toString(arr));
// Вывод: [42, 42, 42, 42, 42, 42, 42, 42, 42, 42]

Вместо:

// Без fill() пришлось бы писать:
int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
    arr[i] = 42;
}

Заполнение части массива

import java.util.Arrays;

int[] arr = new int[10];
Arrays.fill(arr, 3, 7, 99);  // с индекса 3 по 6 (7 не включается)
System.out.println(Arrays.toString(arr));
// Вывод: [0, 0, 0, 99, 99, 99, 99, 0, 0, 0]

Обратите внимание:第二个 параметр (3) — начальный индекс (включается), третий параметр (7) — конечный индекс (НЕ включается). Это аналогично поведению в других методах Java.

Заполнение строковых массивов

import java.util.Arrays;

String[] names = new String[5];
Arrays.fill(names, "Неизвестно");
System.out.println(Arrays.toString(names));
// Вывод: [Неизвестно, Неизвестно, Неизвестно, Неизвестно, Неизвестно]

Заполнение символьных массивов

import java.util.Arrays;

char[] buffer = new char[20];
Arrays.fill(buffer, '*');
System.out.println(Arrays.toString(buffer));
// Вывод: [*, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *]

Применение: fill() часто используется для инициализации массивов-буферов, шаблонов, заполнения пустых ячеек и подготовки данных для обработки.

import java.util.Arrays;

char[][] board = new char[3][3];
for (char[] row : board) {
    Arrays.fill(row, '.');
}
System.out.println(Arrays.deepToString(board));
// Вывод: [[., ., .], [., ., .], [., ., .]]

Arrays.copyOf() — создание копии массива

Метод Arrays.copyOf() создаёт новый массив заданной длины и копирует в него элементы из исходного. Если новый массив длиннее — лишние заполняются значениями по умолчанию. Если короче — лишние элементы не копируются.

Копия той же длины

import java.util.Arrays;

int[] original = {1, 2, 3, 4, 5};
int[] copy = Arrays.copyOf(original, original.length);

System.out.println("Оригинал: " + Arrays.toString(original));
System.out.println("Копия:    " + Arrays.toString(copy));

copy[0] = 999;
System.out.println("После изменения копии:");
System.out.println("Оригинал: " + Arrays.toString(original));
System.out.println("Копия:    " + Arrays.toString(copy));
// Вывод:
// Оригинал: [1, 2, 3, 4, 5]
// Копия:    [1, 2, 3, 4, 5]
// После изменения копии:
// Оригинал: [1, 2, 3, 4, 5]   — не изменился!
// Копия:    [999, 2, 3, 4, 5]

Увеличение массива

import java.util.Arrays;

int[] small = {1, 2, 3};
int[] bigger = Arrays.copyOf(small, 5);

System.out.println(Arrays.toString(bigger));
// Вывод: [1, 2, 3, 0, 0]
// Последние два элемента заполнены нулями (значение по умолчанию для int)

Уменьшение массива

import java.util.Arrays;

int[] big = {10, 20, 30, 40, 50};
int[] small = Arrays.copyOf(big, 3);

System.out.println(Arrays.toString(small));
// Вывод: [10, 20, 30]

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

import java.util.Arrays;

String[] fruits = {"Яблоко", "Банан", "Вишня"};
String[] moreFruits = Arrays.copyOf(fruits, 5);

System.out.println(Arrays.toString(moreFruits));
// Вывод: [Яблоко, Банан, Вишня, null, null]

Arrays.copyOfRange() — копирование части массива

Метод Arrays.copyOfRange() копирует часть исходного массива — от начального индекса (включительно) до конечного (НЕ включительно). Это удобно, когда нужно взять «срез» массива.

import java.util.Arrays;

int[] numbers = {10, 20, 30, 40, 50, 60, 70};

int[] slice = Arrays.copyOfRange(numbers, 2, 5);
System.out.println(Arrays.toString(slice));
// Вывод: [30, 40, 50]
// Копируем индексы 2, 3, 4 (5 не включается)

Синтаксис: Arrays.copyOfRange(массив, откуда, куда)

• откуда — начальный индекс (включается)
• куда — конечный индекс (НЕ включается)

Примеры разных срезов:

import java.util.Arrays;

int[] arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

int[] first3 = Arrays.copyOfRange(arr, 0, 3);
System.out.println("Первые 3: " + Arrays.toString(first3));  // [0, 1, 2]

int[] middle = Arrays.copyOfRange(arr, 3, 7);
System.out.println("Середина: " + Arrays.toString(middle));  // [3, 4, 5, 6]

int[] last3 = Arrays.copyOfRange(arr, 7, 10);
System.out.println("Последние 3: " + Arrays.toString(last3));  // [7, 8, 9]

int[] full = Arrays.copyOfRange(arr, 0, 10);
System.out.println("Полная копия: " + Arrays.toString(full));  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Применение: извлечение подмассива, выделение заголовка из буфера, получение «хвоста» или «головы» списка данных.

import java.util.Arrays;

String[] fullName = {"Иван", "Иванович", "Иванов"};
String[] firstName = Arrays.copyOfRange(fullName, 0, 1);
String[] middleName = Arrays.copyOfRange(fullName, 1, 2);
String[] lastName = Arrays.copyOfRange(fullName, 2, 3);

System.out.println(Arrays.toString(firstName));   // [Иван]
System.out.println(Arrays.toString(middleName));  // [Иванович]
System.out.println(Arrays.toString(lastName));    // [Иванов]

Arrays.equals() — сравнение массивов

В Java оператор == для массивов сравнивает не значения, а ссылки. Два массива с одинаковыми элементами будут «не равны» через ==, потому что это разные объекты в памяти:

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};

System.out.println(a == b);  // false! Ссылки разные

System.out.println(a.equals(b));  // false! По умолчанию тоже ссылки

Чтобы сравнить массивы по содержимому (посимвольно/попозиционно), используйте Arrays.equals():

import java.util.Arrays;

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
int[] c = {1, 2, 4};

System.out.println(Arrays.equals(a, b));  // true — содержимое одинаковое
System.out.println(Arrays.equals(a, c));  // false — разные значения

System.out.println(a == b);  // false — ссылки разные

Метод Arrays.equals() сравнивает:

• Длину массивов (если разная — сразу false)
• Каждый элемент попозиционно
• Для ссылочных типов — через .equals()

import java.util.Arrays;

String[] names1 = {"Анна", "Борис"};
String[] names2 = {"Анна", "Борис"};
String[] names3 = {"Анна", "Борис", "Виктор"};

System.out.println(Arrays.equals(names1, names2));  // true
System.out.println(Arrays.equals(names1, names3));  // false — разная длина

Отличный способ проверить, изменился ли массив после операций:

import java.util.Arrays;

int[] original = {1, 2, 3};
int[] copy = Arrays.copyOf(original, original.length);

System.out.println(Arrays.equals(original, copy));  // true

copy[2] = 99;
System.out.println(Arrays.equals(original, copy));  // false — теперь разные

Arrays.deepEquals() — сравнение многомерных массивов

Для многомерных массивов метод Arrays.equals() не работает корректно — он сравнивает только верхний уровень (ссылки на внутренние массивы). Чтобы сравнить содержимое на всех уровнях, нужен Arrays.deepEquals():

import java.util.Arrays;

int[][] a = {{1, 2}, {3, 4}};
int[][] b = {{1, 2}, {3, 4}};
int[][] c = {{1, 2}, {3, 5}};

System.out.println(Arrays.equals(a, b));      // false! Ссылки на подмассивы разные
System.out.println(Arrays.deepEquals(a, b));   // true — содержимое одинаковое
System.out.println(Arrays.deepEquals(a, c));   // false — разные значения

Разница между equals() и deepEquals():

import java.util.Arrays;

int[][] matrix1 = {{1, 2, 3}, {4, 5, 6}};
int[][] matrix2 = {{1, 2, 3}, {4, 5, 6}};

System.out.println("equals:     " + Arrays.equals(matrix1, matrix2));
System.out.println("deepEquals: " + Arrays.deepEquals(matrix1, matrix2));
// Вывод:
// equals:     false
// deepEquals: true

Правило простое: для одномерных массивов используйте Arrays.equals(), для многомерных — Arrays.deepEquals().

Сравнительная таблица методов

Подведём промежуточный итог и составим удобную шпаргалку по всем методам класса Arrays:

Ручные циклы vs методы Arrays

Возникает закономерный вопрос: когда использовать методы Arrays, а когда писать циклы вручную? Вот руководство:

Используйте методы Arrays когда:

• Нужна сортировка — Arrays.sort() оптимизирован и быстрее вашего кода
• Нужен поиск в отсортированном массиве — Arrays.binarySearch()
• Нужно заполнить весь массив одним значением — Arrays.fill()
• Нужно скопировать массив — Arrays.copyOf()
• Нужно сравнить два массива — Arrays.equals()
• Нужно вывести массив — Arrays.toString()

Используйте ручные циклы когда:

• Нужно изменить каждый элемент по формуле (умножить, сложить с чем-то)
• Нужен обратный обход
• Нужно найти максимум/минимум/среднее — методов для этого нет
• Нужно подсчитать что-то (количество чётных, сумму положительных)
• Нужно отфильтровать элементы (оставить только положительные)
• Нужно найти элемент по условию (первое число больше 100)

Пример: Задача — увеличить каждый элемент на 10%:

import java.util.Arrays;

double[] prices = {100.0, 200.0, 300.0};

// ❌ Нет метода Arrays для этого — нужен цикл
for (int i = 0; i < prices.length; i++) {
    prices[i] *= 1.10;
}

// Или через for-each (но тогда через индекс)
for (int i = 0; i < prices.length; i++) {
    prices[i] = prices[i] * 1.10;
}

System.out.println(Arrays.toString(prices));
// Вывод: [110.0, 220.0, 330.0]

Пример: Задача — найти индекс максимального элемента:

import java.util.Arrays;

int[] heights = {170, 185, 162, 190, 175};

int maxIndex = 0;
for (int i = 1; i < heights.length; i++) {
    if (heights[i] > heights[maxIndex]) {
        maxIndex = i;
    }
}

System.out.println("Максимум " + heights[maxIndex] + " на индексе " + maxIndex);
// Вывод: Максимум 190 на индексе 3

Пример: Комбинируем и циклы, и методы Arrays:

import java.util.Arrays;

int[] scores = {85, 92, 78, 95, 88, 73, 91};

Arrays.sort(scores);
System.out.println("Отсортированные: " + Arrays.toString(scores));

int min = scores[0];
int max = scores[scores.length - 1];
int sum = 0;
for (int score : scores) {
    sum += score;
}
double average = (double) sum / scores.length;

System.out.println("Минимум: " + min);
System.out.println("Максимум: " + max);
System.out.println("Среднее: " + average);

Практические задачи

Задача 1: Убрать дубликаты из отсортированного массива

import java.util.Arrays;

int[] arr = {1, 1, 2, 2, 3, 3, 4, 5, 5};
Arrays.sort(arr);

int unique = 1;
for (int i = 1; i < arr.length; i++) {
    if (arr[i] != arr[i - 1]) {
        arr[unique] = arr[i];
        unique++;
    }
}

int[] result = Arrays.copyOf(arr, unique);
System.out.println(Arrays.toString(result));
// Вывод: [1, 2, 3, 4, 5]

Задача 2: Проверить, является ли массив палиндромом

import java.util.Arrays;

int[] arr = {1, 2, 3, 2, 1};
boolean isPalindrome = true;

for (int i = 0; i < arr.length / 2; i++) {
    if (arr[i] != arr[arr.length - 1 - i]) {
        isPalindrome = false;
        break;
    }
}

System.out.println(Arrays.toString(arr) + " — палиндром? " + isPalindrome);
// Вывод: [1, 2, 3, 2, 1] — палиндром? true

Задача 3: Найти второе по величине число

import java.util.Arrays;

int[] arr = {5, 2, 8, 1, 9, 3};
Arrays.sort(arr);

int secondMax = arr[arr.length - 2];
System.out.println("Второе最大: " + secondMax);
// Вывод: Второе最大: 8

Задача 4: Объединить два отсортированных массива

import java.util.Arrays;

int[] a = {1, 3, 5};
int[] b = {2, 4, 6};
int[] merged = new int[a.length + b.length];

int i = 0, j = 0, k = 0;
while (i < a.length && j < b.length) {
    if (a[i] < b[j]) {
        merged[k++] = a[i++];
    } else {
        merged[k++] = b[j++];
    }
}
while (i < a.length) merged[k++] = a[i++];
while (j < b.length) merged[k++] = b[j++];

System.out.println(Arrays.toString(merged));
// Вывод: [1, 2, 3, 4, 5, 6]

Задача 5: Создать новый массив без отрицательных чисел

import java.util.Arrays;

int[] original = {3, -1, 5, -2, 8, -3, 10};
int count = 0;

for (int num : original) {
    if (num >= 0) count++;
}

int[] positive = new int[count];
int index = 0;
for (int num : original) {
    if (num >= 0) {
        positive[index++] = num;
    }
}

System.out.println("Исходный: " + Arrays.toString(original));
System.out.println("Только положительные: " + Arrays.toString(positive));
// Вывод:
// Исходный: [3, -1, 5, -2, 8, -3, 10]
// Только положительные: [3, 5, 8, 10]

Частые ошибки при работе с методами Arrays

Ошибка 1: Забыть импорт

// ❌ Без импорта — ошибка компиляции
int[] arr = {3, 1, 2};
Arrays.sort(arr);  // Error: cannot find symbol

// ✅ Нужен импорт
import java.util.Arrays;
Arrays.sort(arr);  // Работает!

Ошибка 2: BinarySearch без сортировки

import java.util.Arrays;

int[] arr = {5, 3, 1, 4, 2};
int idx = Arrays.binarySearch(arr, 3);
System.out.println(idx);  // Непредсказуемый результат!

// ✅ Сначала сортируем
Arrays.sort(arr);
idx = Arrays.binarySearch(arr, 3);
System.out.println(idx);  // 1 (корректно)

Ошибка 3: equals() для многомерных массивов

import java.util.Arrays;

int[][] a = {{1, 2}, {3, 4}};
int[][] b = {{1, 2}, {3, 4}};

System.out.println(Arrays.equals(a, b));      // false!
System.out.println(Arrays.deepEquals(a, b));   // true

Ошибка 4: Сравнение строк через ==

import java.util.Arrays;

String[] a = {"Hello"};
String[] b = {"Hello"};

System.out.println(a[0] == b[0]);           // false (может быть!)
System.out.println(a[0].equals(b[0]));       // true
System.out.println(Arrays.equals(a, b));     // true

Ошибка 5: copyOfRange с неверными границами

import java.util.Arrays;

int[] arr = {1, 2, 3, 4, 5};

// ❌ from > to — вернётся пустой массив
int[] empty = Arrays.copyOfRange(arr, 3, 1);
System.out.println(Arrays.toString(empty));  // []

// ✅ from < to
int[] slice = Arrays.copyOfRange(arr, 1, 4);
System.out.println(Arrays.toString(slice));  // [2, 3, 4]

Итоги урока

• Arrays.toString() — красивый вывод массива в строку
• Arrays.sort() — сортирует массив по возрастанию (на месте)
• Arrays.binarySearch() — быстрый поиск в отсортированном массиве (O(log n))
• Arrays.fill() — заполняет массив (или его часть) одним значением
• Arrays.copyOf() — создаёт копию массива заданной длины
• Arrays.copyOfRange() — копирует часть массива по индексам
• Arrays.equals() — сравнивает одномерные массивы по содержимому
• Arrays.deepEquals() — сравнивает многомерные массивы рекурсивно
• Используйте методы Arrays для стандартных операций, ручные циклы — для кастомной логики
• Не забывайте про импорт import java.util.Arrays;

Следующий урок: Многомерные массивы: таблицы и матрицы