Concatenate integer arrays in Java
This post will discuss concatenate integer arrays in Java into a new array without using any external libraries. We will also look at some benefits and limitations of each of the methods.
If you are working with integer arrays in Java, you might have encountered the need to concatenate integer arrays in Java. For example, you might want to merge the results of different computations, or append some values to an existing array. There are several ways to do so:
1. Using Loops
There are different ways to concatenate two or more arrays in Java, but not all of them are equally efficient and elegant. One of the simplest ways to concatenate arrays is to use loops to iterate over the elements of the source arrays and copy them to a new array. The advantage of this method is that it does not require any external library or class. However, the disadvantage is that it is verbose, repetitive, and error-prone. You have to manually allocate the result array with the correct size, keep track of the indices, and write multiple loops for each array. This method also does not scale well if you have more than two arrays to concatenate. For example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
import java.util.Arrays; class Main { public static void main(String[] args) { int[] arr1 = {1, 2, 3}; int[] arr2 = {4, 5}; int[] result = new int[arr1.length + arr2.length]; // Copy elements from arr1 to result for (int i = 0; i < arr1.length; i++) { result[i] = arr1[i]; } // Copy elements from arr2 to result for (int i = 0; i < arr2.length; i++) { result[arr1.length + i] = arr2[i]; } System.out.println(Arrays.toString(result)); // [1, 2, 3, 4, 5] } } |
2. Using System.arraycopy() method
Another way to concatenate arrays is to use the System.arraycopy() method, which is a native method that copies a specified number of elements from one array to another. The advantage of this method is that it is faster and more efficient than using loops, as it uses native code to perform the copying. However, the disadvantage is that it is still verbose and requires manual allocation of the result array. For example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import java.util.Arrays; class Main { public static void main(String[] args) { int[] arr1 = {1, 2, 3}; int[] arr2 = {4, 5}; int[] result = new int[arr1.length + arr2.length]; // Copy elements from arr1 to result System.arraycopy(arr1, 0, result, 0, arr1.length); // Copy elements from arr2 to result System.arraycopy(arr2, 0, result, arr1.length, arr2.length); System.out.println(Arrays.toString(result)); // [1, 2, 3, 4, 5] } } |
3. Using Collections.addAll() method
A third way to concatenate arrays is to use the Collections framework, which provides various classes and methods for working with collections of objects. The advantage of this method is that it is simple and concise, as it uses existing classes and methods to perform the concatenation. However, the disadvantage is that it requires boxing and unboxing of primitive types, which adds overhead and memory consumption. It also creates intermediate list objects and does not handle null arrays gracefully. For example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; class Main { public static void main(String[] args) { Integer[] arr1 = {1, 2, 3}; Integer[] arr2 = {4, 5}; List<Integer> list = new ArrayList<>(); // Add elements from arr1 to list Collections.addAll(list, arr1); // Add elements from arr2 to list Collections.addAll(list, arr2); // Convert list to array Integer[] result = list.toArray(new Integer[0]); System.out.println(Arrays.toString(result)); // [1, 2, 3, 4, 5] } } |
4. Using Stream API
Finally, you can concatenate arrays is to use the Stream API, which was introduced in Java 8 and provides a functional way of processing collections of data. The advantage of this method is that it is elegant and expressive, as it uses a fluent and declarative style of programming. However, the disadvantage is that it may not be as efficient as other methods, as it involves creating and manipulating streams and lambdas, which may incur overhead and memory consumption. For example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import java.util.Arrays; import java.util.stream.IntStream; class Main { public static void main(String[] args) { int[] arr1 = {1, 2, 3}; int[] arr2 = {4, 5}; // Create streams from arrays IntStream stream1 = Arrays.stream(arr1); IntStream stream2 = Arrays.stream(arr2); // Concatenate streams and convert to array int[] result = IntStream.concat(stream1, stream2).toArray(); System.out.println(Arrays.toString(result)); // [1, 2, 3, 4, 5] } } |
You can also use third party libraries such as Guava to concatenate integer arrays in Java. You can use the Ints.concat() utility method that combines the values of many int arrays into a single int array, which is discussed in this post.
That’s all about concatenating integer arrays in Java without using any external libraries.
Thanks for reading.
To share your code in the comments, please use our online compiler that supports C, C++, Java, Python, JavaScript, C#, PHP, and many more popular programming languages.
Like us? Refer us to your friends and support our growth. Happy coding :)