В этой статье я покажу 10 часто используемых приёмов, которые пригодятся тебе в реальных проектах. Каждый приём проверен временем — эти решения чаще всего ищут на Stack Overflow и используют в production-коде. Самое важное: я покажу современные подходы (Java 8+) и объясню, почему старые методы уже не стоит использовать. Поехали!10 часто используемых приёмов для работы с массивом в Java - 1Массивы — это основа программирования. Работаешь ли ты с небольшим списком имён или обрабатываешь тысячи записей из базы данных — умение эффективно работать с массивами отличает джуниора от мидла.

1. Объявление массива — три способа

Начнём с азов. Есть три способа создать массив, и все они валидны: 

// Способ 1: указываем размер
String[] names = new String[5];

// Способ 2: инициализация значениями (короткая форма)
String[] fruits = {"яблоко", "банан", "груша"};

// Способ 3: полная форма (нужна, когда передаём в метод)
String[] colors = new String[]{"красный", "синий", "зелёный"};
Когда что использовать? Если размер заранее известен — используй способ 2 (самый читаемый). Если нужно передать массив прямо в метод — способ 3. Способ 1 используется, когда заполнять массив будешь позже.

2. Вывод массива — не наступи на грабли

Новички часто делают так: 

int[] numbers = {1, 2, 3, 4, 5};
System.out.println(numbers);
// Вывод: [I@7150bd4d  ← Это адрес в памяти, а не содержимое!
Правильный способ: 

System.out.println(Arrays.toString(numbers));
// Вывод: [1, 2, 3, 4, 5]  ← То, что нужно!
Для многомерных массивов: 

int[][] matrix = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepToString(matrix));
// Вывод: [[1, 2], [3, 4]]
Запомни: Arrays.toString() — твой лучший друг при отладке.

3. Преобразование массива в список — осторожно с ловушками

Старый способ (до Java 9):
Java-университет 

String[] languages = {"Java", "Python", "JavaScript"};
ArrayList<String> list = new ArrayList<>(Arrays.asList(languages));
Современный способ (Java 9+): 

List<String> immutableList = List.of("Java", "Python", "JavaScript");

// Если нужен изменяемый список:
List<String> mutableList = new ArrayList<>(List.of("Java", "Python"));
⚠️ Важная ловушка! 

List<String> list = Arrays.asList("Java", "Python");
list.add("C++");  // ОШИБКА! UnsupportedOperationException
Arrays.asList() возвращает список фиксированного размера. Добавлять и удалять элементы нельзя! Если нужна возможность модификации — оборачивай в new ArrayList<>().

4. Проверка наличия элемента — давай по-современному

Старый неэффективный способ: 

String[] cities = {"Москва", "Киев", "Минск"};
boolean found = Arrays.asList(cities).contains("Киев");
// Проблема: создаёт временный список для одной проверки!
Современный способ (Java 8+): 

boolean found = Arrays.stream(cities)
    .anyMatch(city -> city.equals("Киев"));
Если проверок много — используй Set: 

Set<String> citySet = Set.of(cities);
boolean found = citySet.contains("Киев");  // O(1) вместо O(n)!
Золотое правило: Одна проверка — используй stream. Много проверок в одном массиве — преобразуй в Set один раз.

5. Объединение массивов — забудь про Apache Commons

Старый способ (требует библиотеку Apache Commons): 

int[] first = {1, 2, 3};
int[] second = {4, 5, 6};
int[] combined = ArrayUtils.addAll(first, second);
Современный способ (Java 8+, без зависимостей!): 

int[] combined = IntStream.concat(
    IntStream.of(first),
    IntStream.of(second)
).toArray();
Для объектных массивов: 

String[] names1 = {"Аня", "Боря"};
String[] names2 = {"Вера", "Гена"};

String[] allNames = Stream.concat(
    Arrays.stream(names1),
    Arrays.stream(names2)
).toArray(String[]::new);
Бонус: Если массивов больше двух, используй Stream.of().flatMap() — объединишь за один проход.

6. Объединение элементов в строку — String.join() спешит на помощь

Старый способ (Apache Commons): 

String[] words = {"Java", "это", "круто"};
String result = StringUtils.join(words, " ");
Современный способ (Java 8+): 

String result = String.join(" ", words);
// Результат: "Java это круто"
Ещё варианты: 

// С коллекцией
List<String> list = List.of("a", "b", "c");
String joined = String.join(", ", list);

// Через Stream (когда нужна обработка)
String result = Arrays.stream(words)
    .map(String::toUpperCase)
    .collect(Collectors.joining(", "));
// Результат: "JAVA, ЭТО, КРУТО"
String.join() работает быстрее чем ручная конкатенация через цикл. Внутри используется StringBuilder, поэтому не бойся больших массивов.

7. Преобразование списка в массив — два современных способа

Способ 1: Через toArray() с готовым массивом 

List<String> list = List.of("Java", "Python", "C++");
String[] array = list.toArray(new String[0]);
Способ 2: Через Stream (Java 11+) 

String[] array = list.stream()
    .toArray(String[]::new);
❓ Почему new String[0], а не new String[list.size()]? Раньше считалось, что нужно заранее создать массив правильного размера. Но начиная с Java 6, JVM оптимизирована так, что new String[0] работает быстрее! Внутри метод всё равно создаст массив нужного размера. Совет: Если работаешь только с коллекциями — оставайся в мире List, не конвертируй туда-сюда. Массивы нужны только для работы со старым API или performance-критичным кодом.

8. Преобразование массива в Set — удаляем дубликаты

Старый способ: 

String[] colors = {"красный", "синий", "красный", "зелёный"};
Set<String> uniqueColors = new HashSet<>(Arrays.asList(colors));
Современный способ (Java 8+): 

Set<String> uniqueColors = Arrays.stream(colors)
    .collect(Collectors.toSet());
Или самый короткий вариант (Java 10+): 

Set<String> uniqueColors = Set.of(colors);  // Неизменяемый Set
⚠️ Внимание: Set.of() бросит исключение, если в массиве есть дубликаты! Используй его только когда уверен, что дубликатов нет. Практический пример: Удаление дубликатов из списка email-адресов перед отправкой рассылки.

9. Разворот массива — делаем сами или используем Collections

Старый способ (Apache Commons): 

int[] numbers = {1, 2, 3, 4, 5};
ArrayUtils.reverse(numbers);
Современный способ — ручная реализация: 

public static void reverse(int[] array) {
    for (int i = 0; i < array.length / 2; i++) {
        int temp = array[i];
        array[i] = array[array.length - 1 - i];
        array[array.length - 1 - i] = temp;
    }
}
Для объектных массивов: 

String[] words = {"one", "two", "three"};
List<String> list = Arrays.asList(words);
Collections.reverse(list);
// Теперь words = {"three", "two", "one"}
Важно: Collections.reverse() меняет исходный массив через обёртку Arrays.asList(). Если нужна копия — сначала создай новый массив.

10. Удаление элемента — массивы неизменяемы, но есть решение

Важно понимать: В Java нельзя удалить элемент из массива напрямую — размер массива фиксирован! Нужно создавать новый массив. Старый способ (Apache Commons): 

int[] numbers = {1, 2, 3, 4, 5};
int[] result = ArrayUtils.removeElement(numbers, 3);
Современный способ (Java 8+):
ALL IN ONE 

// Удаление по значению
int[] result = Arrays.stream(numbers)
    .filter(n -> n != 3)
    .toArray();

// Удаление по индексу
int indexToRemove = 2;
int[] result = IntStream.range(0, numbers.length)
    .filter(i -> i != indexToRemove)
    .map(i -> numbers[i])
    .toArray();
Для объектных массивов: 

String[] names = {"Аня", "Боря", "Вера", "Гена"};
String[] filtered = Arrays.stream(names)
    .filter(name -> !name.equals("Боря"))
    .toArray(String[]::new);
💡 Профессиональный совет: Если часто добавляешь/удаляешь элементы — используй ArrayList, а не массив. Массивы — для данных фиксированного размера.

Бонус: Преобразование int в byte[]

Иногда нужно преобразовать число в массив байтов (например, для работы с сетевыми протоколами): 

int number = 12345;
byte[] bytes = ByteBuffer.allocate(4).putInt(number).array();

// Посмотрим содержимое
for (byte b : bytes) {
    System.out.format("0x%02X ", b);
}
// Вывод: 0x00 0x00 0x30 0x39
ByteBuffer — это мощный инструмент для работы с бинарными данными. Понадобится при работе с файлами, сетью или криптографией.

Заключение

Теперь у тебя в арсенале 10 современных приёмов работы с массивами. Главные выводы:
  • Stream API (Java 8+) заменяет большинство методов из Apache Commons
  • String.join() и List.of() упрощают код и делают его читаемым
  • Arrays.toString() — must have для отладки массивов
  • Если часто модифицируешь данные — используй ArrayList, а не массив
Практикуйся с этими приёмами в реальных проектах — они встречаются постоянно. Со временем ты будешь использовать их на автомате, даже не задумываясь. Удачи в изучении Java! 🚀