How to Merge Two Arrays in Java?

Merging two arrays in Java is a fundamental operation that is often required in various applications. It can be done in several ways depending on the specific requirements and constraints of the problem at hand.

Merging two arrays in Java is similar to concatenate or combine two arrays in a single array object. We have to merge two arrays such that the array elements maintain their original order in the newly merged array. The elements of the first array precede the elements of the second array in the newly merged array.

For example:

Use Cases

Merging two arrays in Java is a common task in various scenarios, including:

Data Processing: When working with datasets stored in multiple arrays, merging them allows for streamlined data processing and analysis. For example, merging arrays of student names and corresponding grades facilitates calculating averages or sorting based on grades.

User Input: In applications where users can input data in batches or sections, merging arrays enables combining multiple input arrays into a single dataset for further processing or storage.

Database Operations: When retrieving data from a database, results may be stored in separate arrays representing different columns or attributes. Merging these arrays consolidates the data for presentation or manipulation.

Sorting and Searching: Merging arrays is often a prerequisite for sorting or searching algorithms. Before applying these operations, it's essential to merge smaller arrays into larger ones to ensure proper sorting or searching across the entire dataset.

Resource Management: In resource-constrained environments, merging arrays conserves memory by minimizing the number of separate arrays, leading to more efficient resource utilization.

Ways to Merge Two Arrays

There are the following ways to merge two arrays:

• Java System.arraycopy() Method
• Without Using arraycopy() Method
• Java Collections
• Java Stream API

Java System.arraycopy() Method

The System.arraycopy() method in Java is a powerful and efficient way to copy elements from one array to another. It is used to perform a shallow copy of array elements. It can be employed to copy elements from one array to another, to copy a subarray, or to shift elements within an array. The number of elements copied is equal to the length argument.

Syntax:

Parameters

• source: It is a source array.
• source_position: Starting point in the source array.
• destination: It is a destination array.
• destination_position: Starting position in the destination array.
• length: The number of array elements to be copied

It throws NullPointerException if the source or destination array is null. It also throws ArrayIndexOutOfBoundsException if:

• source_position or destination_position or length is negative.
• source_position+length is greater than the length of the source array, or destination_position+length is greater than the length of the destination array.

Example of arraycopy() Method

In the following example, we have created two integer arrays firstArray and secondArray. In order to merge two arrays, we find its length and stored in fal and sal variable respectively. After that, we create a new integer array result which stores the sum of length of both arrays. Now, copy each elements of both arrays to the result array by using arraycopy() function.

MergeArrayExample1.java

Output:

 [23, 45, 12, 78, 4, 90, 1, 77, 11, 45, 88, 32, 56, 3] 

Let's see another example in which we have specified soure_array, destination, dest_position, source position, and length. We can merge array according to the specified positions and length.

Example

MergeArrayExample2.java

Output:

 source_array: 11 22 33 44 55 98 76 54 60 sourcePos: 2 dest_array: 66 77 88 99 22 67 21 90 80 70 destPos: 4 len: 3 Resultant array: 66 77 88 99 33 44 55 90 80 70 

Without using arraycopy() method

The System.arraycopy() method is an efficient native method in Java for copying elements between arrays. It handles type safety, bounds checking, and performs the copy operation much faster than a manual loop due to its low-level implementation. Without using System.arraycopy(), one must manually loop through the source array to copy elements to the destination array, which is less efficient and more error-prone, especially for large arrays. Here's a simple example of manually copying elements using loops:

Example of Merging Two Arrays

In the following example, we have initialized two arrays firstArray and secondArray of integer type. Manually copy the each element of both arrays to mergedArray and convert that array into String by using the toString() method of Array class.

MergeArrayExample3.java

Output:

 [56, 78, 90, 32, 67, 12, 11, 14, 9, 5, 2, 23, 15] 

Using Collections

Using Java Collections Framework provides a flexible and efficient way to manage groups of objects. Collections, such as ArrayList, LinkedList, HashSet, and HashMap, offer dynamic data structures that can grow or shrink as needed, unlike fixed-size arrays. They come with built-in methods for adding, removing, and manipulating elements, making tasks like sorting, searching, and merging simpler and more efficient.

For example, ArrayList allows dynamic resizing and provides methods like add(), remove(), and get(). Collections also support generics, ensuring type safety at compile-time. Merging two collections can be easily done using methods like addAll():

Example of Merging Two Arrays in Java

In the following example, we have initialized two arrays str1 and str2 of String type. After that we have created a list view of str1 by using the Arrays.asList() method. Now we have created the list view of str2 and added all the elements of str2 into the list. Again perform conversion from list to array and store the resultant array into str3 variable.

MergeArrayExample4.java

Output:

 [A, E, I, O, U] 

Java Stream API

Stream.of() Method

The Stream.of() method of Stream interface returns a sequential ordered stream whose elements are the values.

Syntax

Where, T is the type of stream elements. The method accepts values (elements of the new stream).

Stream.flatMap() Method

The Stream.flatMap() method is the method of Stream interface. It returns a stream consisting of the result.

Syntax

Where R is the element type of new stream. The method accepts a mapper (a function to apply to each element which produces a stream of new values) as a parameter.

Stream.toArray() Method

The Stream.toArray() method of Stream interface returns an array containing the elements of the stream.

Syntax

Example of Merging Two Arrays Using Stream API

MergeArrayExample5.java

Output:

 Merged array: [13, 12, 11, 6, 9, 3, 78, 34, 56, 67, 2, 11, 7] 

Best Practices

• Bounds Checking: Always ensure that the indices and lengths specified do not exceed the bounds of the arrays.
• Type Compatibility: Ensure that the source and destination arrays are of compatible types to avoid ArrayStoreException.
• Null Checks: Always check for null arrays to avoid NullPointerException.
• Consistent Naming: Use clear and descriptive names for arrays to improve code readability and maintainability.
• Encapsulation: Encapsulate arrays within classes or methods to control access and prevent unintended modifications.
• Immutable Arrays: Consider using immutable or read-only arrays when appropriate to prevent accidental changes.
• Performance Optimization: Optimize array operations for efficiency, especially for large arrays or performance-sensitive applications.
• Documentation and Comments: Provide clear documentation and comments to explain the purpose, usage, and constraints of array-related code.

Conclusion

The System.arraycopy() method is a versatile and efficient tool for copying array elements in Java. By understanding its parameters, handling exceptions, and knowing when to use it, we can effectively manage array manipulations in your Java applications. Whether merging arrays, copying subarrays, or shifting elements, System.arraycopy() provides a robust solution for these tasks.