1. Introduction
As Java developers, we might encounter situations where we want to concatenate two or more byte arrays. In this tutorial, we’ll explore several ways to concatenate two or more byte arrays.
We’ll start with the plain Java classes and methods. Then, we’ll look at some external libraries like Guava and Apache Commons Collections for combining byte arrays.
2. Using Plain Java
In all the following examples, we’ll consider the following two byte arrays:
byte[] first = {69, 121, 101, 45, 62, 118, 114};
byte[] second = {58, 120, 100, 46, 64, 114, 103, 117};
To store these two concatenated arrays, we’ll need a new resultant array:
byte[] combined = new byte[first.length + second.length];
The expected resultant array will be the following:
byte[] expectedArray = {69, 121, 101, 45, 62, 118, 114, 58, 120, 100, 46, 64, 114, 103, 117};
In a couple of examples, we’ll look at methods that allow us to combine more than two arrays. We’ll consider one more byte array for concatenation:
byte[] third = {55, 66, 11, 111, 25, 84};
In this case, the expected resultant array after the concatenation of three arrays would be the following:
byte[] expectedArray = {69, 121, 101, 45, 62, 118, 114, 58, 120, 100, 46, 64, 114, 103, 117, 55, 66, 11, 111, 25, 84};
2.1. Using System.arraycopy()
arrayCopy() is a static method in the System class. It copies an array or a subsequence of an array from the specified source array, beginning at the specified position, to the specified position of the destination array.
This method accepts the source and destination arrays, positions in the arrays and length as parameters required to copy the array elements. Let’s look at its signature:
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
We’ll understand what these parameters mean:
- src is the source array
- srcPos is the starting position in the source array
- dest is the destination array
- destPos is the starting position in the destination array
- length is the number of array elements to be copied
Let’s use the arrayCopy() method to copy it to our combined array:
System.arraycopy(first, 0, combined, 0, first.length);
System.arraycopy(second, 0, combined, first.length, second.length);
assertArrayEquals(expectedArray, combined);
If we run the test above, it passes.
2.2. Using ByteBuffer
ByteBuffer is a Java class that extends java.nio.Buffer. We can use it to combine two or more byte arrays:
ByteBuffer buffer = ByteBuffer.wrap(combined);
buffer.put(first);
buffer.put(second);
buffer.put(third);
combined = buffer.array();
assertArrayEquals(expectedArray, combined);
Again, the test passes if we give it a run.
2.3. Using a Custom Method
We can concatenate two byte arrays by writing our custom logic. For instance, we can insert into the resultant array by comparing the index with the length of the first array:
for (int i = 0; i < combined.length; ++i) {
combined[i] = i < first.length ? first[i] : second[i - first.length];
}
assertArrayEquals(expectedArray, combined);
We see that the test above passes when we run it.
3. External Libraries
We can use several external libraries to concatenate two byte arrays. We’ll look at the most popular ones.
3.1. Using Guava
Let’s start by adding Google’s Guava Maven dependency in the pom.xml:
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>31.1-jre</version>
</dependency>
We’ll use Guava’s com.google.common.primitives.Bytes.concat(). Here’s its signature:
public static byte[] concat(byte[]... arrays)
We can combine two or more byte arrays using the above method:
byte[] combined = Bytes.concat(first, second, third);
assertArrayEquals(expectedArray, combined);
As we can see, the resultant combined array contains elements from all the arrays passed to the concat() method.
3.2. Using Apache Commons
To get started using Apache Commons Lang 3, we first need to add the Maven dependency:
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.14.0</version>
</dependency>
We’ll use Apache Commons Lang’s org.apache.commons.lang3.ArrayUtils:
public static byte[] addAll(final byte[] array1, final byte... array2)
Let’s see how we can combine two byte arrays using the above method:
byte[] combined = ArrayUtils.addAll(first, second);
assertArrayEquals(expectedArray, combined);
Again, the test passes if we give it a run.
4. Conclusion
In this short article, we first looked at a few methods to concatenate two byte arrays using plain Java. Later, we also used external libraries like Guava and Apache Commons to concatenate two byte arrays.
As always, the complete code samples for this article can be found over on GitHub.
