Easy way to concatenate two byte arrays

java

bytearray

concatenation

ioexception

byAnton Shumikhin·Sep 28, 2024

byte[] result = Arrays.copyOf(first, first.length + second.length); // Create copy of the first array with additional space for the second one
System.arraycopy(second, 0, result, first.length, second.length); // Teleport second array into the free space (aka "concatenation")

This utilizes Arrays.copyOf to create an array with the total length needed, and System.arraycopy to teleport the second array into our result, starting where first ends. This cuts down steps and optimizes performance, plus, it's easy to understand.

In-depth walkthrough

ByteArrayOutputStream: the multi-tasker

A flexible way to concatenate byte arrays is through ByteArrayOutputStream:

ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); // Create an empty vessel
outputStream.write(first); // Pour in the first potion
outputStream.write(second); // Add the second potion into the mix
byte[] combined = outputStream.toByteArray(); // Voila! A new magical array is born!

Handling multiple source arrays or unknown array lengths is a cakewalk with it. Plus, it saves you from the awkward silent error caused by array index misuse!

ByteBuffer: the NIO champion

Having to work with NIO? ByteBuffer has got your back for efficient and chainable concatenation:

ByteBuffer buffer = ByteBuffer.allocate(first.length + second.length); // Time to stretch and allocate some room
buffer.put(first); // In goes the first byte array
buffer.put(second); // Followed by the second one
byte[] combined = buffer.array(); // And... cut! We have our combined array

Beware of the ByteBuffer's hocus-pocus with 'position' and 'limit' which dictate how bytes move into and out of the buffer.

Guava and Apache Commons: the third-party heroes

Fancy a more straightforward and readable code? Guava's Bytes.concat and Apache Commons Lang's ArrayUtils.addAll are the perfect match.

// Guava's way of saying "United we stand"
byte[] combined = Bytes.concat(first, second);

// Apache Commons' style of getting together 
byte[] combined = ArrayUtils.addAll(first, second);

These guys handle the mundane copying process for you and simplify the magic spell when it comes to complex tasks or multiple arrays.

Bonus tips

Know your array length

Avoiding array resizing during concatenation is crucial for performance. Make sure to calculate the length of the result array beforehand.

System.arraycopy: the speedster

For the need-for-speed moments, go for System.arraycopy, which has its roots in native code, ensuring a high-speed performance for bulk copying.

Beware of large arrays

Concatenating large arrays is a tricky task. Always keep an eye on the size to make sure you don't run into an OutOfMemoryError. Try to reuse buffers where possible.

The magic in action

Let's merge two byte arrays, much like making a delicious trail mix:

Byte Array A: [🔵, 🔵🔵]
Byte Array B: [🟢🟢, 🟢]

Adding them into our byte jar:

Combined Array: [🔵, 🔵🔵, 🟢🟢, 🟢]

The blue and green bytes come together like nuts and raisins to form a cohesive byte mix!

When things get tricky

When you have more than two arrays

When the number of arrays increases, a loop with System.arraycopy or a ByteArrayOutputStream would make things easier as they can accommodate multiple arrays without breaking a sweat.

Order of bytes

While merging bytes that represent numbers, make sure to check the endianess. The byte order can change how the values are interpreted when turning the array back to numbers. A bit like reversing a spell!