Как объединить два массива в Java: 5 способов + примеры кода

«Склеиваем» массивы в Java: 5 проверенных способов (с кодом)

Привет, коллега! Если ты читаешь этот текст, значит столкнулся с задачей, которая рано или поздно встаёт перед каждым Java-разработчиком — как объединить два массива в Java? Казалось бы, что может быть проще? Взять и сложить. Но не тут-то было. В Java нет нативного оператора для конкатенации массивов (как в Python или JavaScript). И тут начинается самое интересное.

На Stack Overflow вопрос «How can I concatenate two arrays in Java?» собрал сотни тысяч просмотров. Это значит, что даже опытные ребята иногда теряются в выборе. В этом туториале я покажу тебе 5 рабочих способов — от «дедовского» ручного копирования до современного Stream API. Ты узнаешь плюсы и минусы каждого подхода и сможешь выбрать тот, который подходит именно для твоей задачи.

Погнали!

Почему в Java нет простого способа объединить массивы?

Массив в Java — это объект фиксированной длины. Ты не можешь просто «добавить» один массив в конец другого. Нужно создавать новый массив и копировать в него элементы. Но не переживай — я покажу, как сделать это элегантно и без боли.

Способ 1: Ручное копирование (для тех, кто любит всё контролировать)

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

public class ArrayConcatManual {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};

        int[] result = new int[array1.length + array2.length];

        // Копируем первый массив
        for (int i = 0; i < array1.length; i++) {
            result[i] = array1[i];
        }

        // Копируем второй массив
        for (int i = 0; i < array2.length; i++) {
            result[array1.length + i] = array2[i];
        }

        // Вывод результата
        for (int num : result) {
            System.out.print(num + " ");
        }
        // Вывод: 1 2 3 4 5 6
    }
}

Плюсы: полный контроль, не требует сторонних библиотек, легко читается.

Минусы: многословно, легко ошибиться в индексах (особенно если массивов больше двух).

Совет: Используй этот способ, если хочешь понять, как всё работает «под капотом», или если пишешь код для учебных целей.

Способ 2: System.arraycopy() — стандартный инструмент

В Java есть встроенный метод System.arraycopy(). Он работает быстрее ручного цикла, потому что использует нативный код (native method). Это рекомендуемый способ для продакшена.

import java.util.Arrays;

public class ArrayConcatSystem {
    public static void main(String[] args) {
        String[] fruits1 = {"apple", "banana"};
        String[] fruits2 = {"cherry", "date"};

        String[] result = new String[fruits1.length + fruits2.length];

        System.arraycopy(fruits1, 0, result, 0, fruits1.length);
        System.arraycopy(fruits2, 0, result, fruits1.length, fruits2.length);

        System.out.println(Arrays.toString(result));
        // Вывод: [apple, banana, cherry, date]
    }
}

Как это работает:

• Первый аргумент — исходный массив.
• Второй — начальная позиция в исходном массиве (обычно 0).
• Третий — целевой массив.
• Четвертый — начальная позиция в целевом массиве.
• Пятый — количество копируемых элементов.

Плюсы: быстро, компактно, стандартная библиотека.

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

Способ 3: ArrayList и коллекции — гибкость и удобство

Если тебе нужно не просто объединить массивы, но и потом с ними работать (добавлять, удалять элементы), лучше использовать коллекции. Преобразуем массивы в список, объединяем, и, если нужно, обратно в массив.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ArrayConcatList {
    public static void main(String[] args) {
        Integer[] numbers1 = {10, 20, 30};
        Integer[] numbers2 = {40, 50};

        List<Integer> list = new ArrayList<>();
        list.addAll(Arrays.asList(numbers1));
        list.addAll(Arrays.asList(numbers2));

        Integer[] result = list.toArray(new Integer[0]);

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

Важно: Этот способ работает только с объектными типами (Integer[], String[]). Для примитивов (int[], double[]) нужно сначала преобразовать их в объектные — это лишняя работа.

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

Минусы: создаёт лишние объекты, не подходит для примитивов напрямую.

Способ 4: Apache Commons Lang (ArrayUtils) — «швейцарский нож»

Если ты используешь сторонние библиотеки (а в реальных проектах это норма), обрати внимание на Apache Commons Lang. У него есть готовый метод ArrayUtils.addAll(). Просто и элегантно.

Сначала добавь зависимость в pom.xml (Maven):

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

А теперь код:

import org.apache.commons.lang3.ArrayUtils;

public class ArrayConcatCommons {
    public static void main(String[] args) {
        int[] first = {1, 2, 3};
        int[] second = {4, 5};

        int[] result = ArrayUtils.addAll(first, second);

        System.out.println(ArrayUtils.toString(result));
        // Вывод: {1,2,3,4,5}
    }
}

Плюсы: лаконично, работает с примитивами, надёжно (библиотека проверена миллионами проектов).

Минусы: нужно подключать внешнюю зависимость.

Способ 5: Stream API (Java 8+) — современно и красиво

Если ты используешь Java 8 или новее, Stream API — твой друг. С помощью Stream.concat() можно объединить два массива в одну строку кода. Бонус: легко фильтровать, сортировать и преобразовывать.

import java.util.Arrays;
import java.util.stream.Stream;

public class ArrayConcatStream {
    public static void main(String[] args) {
        String[] cities1 = {"Moscow", "London"};
        String[] cities2 = {"Tokyo",