How to Concatenate Two Arrays in Java

In Java, concatenating two arrays isn’t as straightforward as using the + operator, but there are several efficient ways to achieve this. Here are some of the most popular and reliable methods for merging arrays, from using libraries like Apache Commons and Guava to native Java solutions that avoid extra dependencies.

1. Using Apache Commons ArrayUtils

Apache Commons Lang provides a one-line solution to concatenate arrays with the ArrayUtils.addAll() method. If you’re already using Apache Commons in your project, this is an efficient and straightforward option.

import org.apache.commons.lang3.ArrayUtils;

String[] both = ArrayUtils.addAll(first, second);

This method requires the Apache Commons Lang library, so consider this option if you’re comfortable with adding a library dependency.

2. Using System.arraycopy for Efficient Copying

Java’s built-in System.arraycopy provides a highly efficient way to merge two arrays by copying elements directly. Here’s a two-line solution that creates a new array with the combined length and then copies both arrays into it.

String[] both = Arrays.copyOf(first, first.length + second.length);
System.arraycopy(second, 0, both, first.length, second.length);

This method is efficient and works with both object and primitive arrays, making it a versatile choice.

3. Using Java Streams (Java 8+)

If you’re using Java 8 or higher, the Stream API offers a clean way to concatenate arrays. The Stream.concat method allows you to combine two arrays into one.

String[] both = Stream.concat(Arrays.stream(first), Arrays.stream(second))
                      .toArray(String[]::new);

Or, using Stream.of and flatMap:

String[] both = Stream.of(first, second)
                      .flatMap(Stream::of)
                      .toArray(String[]::new);

This method is elegant but may not be as performant for very large arrays due to the intermediate objects created by streams.

4. Creating a Fully Generic Method

To concatenate arrays of any type, you can create a generic method that works with both objects and primitives. This method uses System.arraycopy to ensure efficiency.

public static <T> T[] concatenate(T[] first, T[] second) {
    T[] result = Arrays.copyOf(first, first.length + second.length);
    System.arraycopy(second, 0, result, first.length, second.length);
    return result;
}

This method handles various types and provides a flexible way to concatenate arrays while maintaining type safety.

5. Using Guava’s ObjectArrays.concat

Google’s Guava library offers a method specifically for concatenating arrays, ObjectArrays.concat. If you’re using Guava, this method is an excellent alternative to ArrayUtils.

String[] both = ObjectArrays.concat(first, second, String.class);

Guava also provides specialized methods for primitive arrays like Ints.concat and Doubles.concat, which further enhance type-specific array operations.

6. Concatenating Arrays with ArrayList

For a more manual approach, you can use an ArrayList to collect elements from both arrays and then convert the list back to an array. This approach is useful when you’re working with dynamic data structures or need to frequently add elements to your arrays.

public String[] concatenateUsingArrayList(String[] first, String[] second) {
    List<String> list = new ArrayList<>(first.length + second.length);
    Collections.addAll(list, first);
    Collections.addAll(list, second);
    return list.toArray(new String[0]);
}

This method is a bit slower than using System.arraycopy but allows for more flexible manipulation of data during concatenation.

Summary of Concatenation Methods

Method	Description	Requires Additional Library?
ArrayUtils.addAll	One-line solution from Apache Commons	Yes (Apache Commons)
System.arraycopy	Efficient copy using Java’s native API	No
Stream.concat / Stream.of	Concise approach using Java 8+ streams	No
Generic method with <T>	Type-safe, reusable method for any type	No
ObjectArrays.concat (Guava)	Efficient solution for Guava users	Yes (Guava)
ArrayList approach	Flexible, allows dynamic manipulation	No

Each of these methods has its advantages, so choose the one that best fits your project requirements and environment. For most use cases, System.arraycopy or ArrayUtils.addAll provides the best performance and simplicity, while Stream methods offer a more modern and functional approach if you’re using Java 8 or later.