Merge arrays into a new object array in Java

Given two arrays of the same type, they need to be merged into a new object array. The task is to merge the two arrays of the same type into an object array such that the array elements maintain their original order in the newly merged array and the elements of the first array precedes the elements of the second array in the merged object array.

This merging can be done in many ways in Java, like Java8, System.arrraycopy() and Java Collections.

  1. Java 8: In Java8 this can be done using the Stream API.
    • Using Stream.of(), flatMap() and toArray() methods:

      Class hierarchy of Stream :

      java.lang.Object
        ↳  java.util.stream
      

      Method description

      Modifier and Type Method Description
      static <T> Stream<T> of(T… values) Returns a sequential ordered stream whose elements are the specified values.
      <R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R%gt;> mapper) Returns a stream of object after applying mapping function on each element and then flattens the result.
      Object[] toArray() Returns an array containing the elements of this stream.

      Examples:



      Input : a[] = {1, 2, 3}
              b[] = {4, 5, 6}
      Output : {1, 2, 3, 4, 5, 6}
      

      Explanation:
      Stream.of(a, b) gets the arrays and pipeline them into a single stream. Then the flatMap() method returns a stream of object after applying mapping function on each element of the Stream.of() and then flattens the result. At the end, toArray() converts the stream elements into an array and return the formed array.

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // Java program to merge two arrays of 
      // same type into an Object array.
        
      import java.util.stream.Stream;
      import java.util.Arrays;
      import java.io.*;
        
      class GFG {
            
          public static <T> Object[] concatenate(T[] a, T[] b)
          {
              // Function to merge two arrays of 
              // same type
              return Stream.of(a, b)
                           .flatMap(Stream::of)
                           .toArray();
        
              // Arrays::stream can also be used in place
              // of Stream::of in the flatMap() above.
          }
            
          public static void main (String[] args) 
          {
              Integer[] a = new Integer[]{1,2,3};
              Integer[] b = new Integer[]{4,5,6};
            
              Object[] c = concatenate(a,b);
                
        
          System.out.println("Merged object array : "
                             + Arrays.toString(c));
          }
      }

      chevron_right

      
      

      Output :

      Merged object array : [1, 2, 3, 4, 5, 6]
      

    • Using Stream.concat(), Arrays.stream() and toArray() methods:

      Method description

      Modifier and Type Method Description
      static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.

      Examples:

      Input : a[] = {1, 2, 3}
              b[] = {4, 5, 6}
      Output : {1, 2, 3, 4, 5, 6}
      

      Explanation:
      The Stream.concat() creates a merged stream in which the elements in the order in which they are in the parameter. Here the Stream.concat() creates a concatenated stream whose elements are all the elements of stream converted from array ‘a’ followed by all the elements of stream converted from array ‘b’. The concatenated stream is then converted to the array and returned.

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // Java program to merge two arrays of 
      // same type into an Object array.
        
      import java.util.stream.Stream;
      import java.util.Arrays;
      import java.io.*;
        
      class GFG {
            
          public static <T> Object[] concatenate(T[] a, T[] b)
          {
              // Function to merge two arrays of 
              // same type
              return Stream.concat(Arrays.stream(a), 
                                   Arrays.stream(b))
                           .toArray();
          }
            
          public static void main (String[] args) 
          {
              Integer[] a = new Integer[]{1,2,3};
              Integer[] b = new Integer[]{4,5,6};
            
              Object[] c = concatenate(a,b);
                
        
          System.out.println("Merged object array : "
                             + Arrays.toString(c));
          }
      }

      chevron_right

      
      

      Output :

      Merged object array : [1, 2, 3, 4, 5, 6]
      


  2. System.arraycopy(): The java.lang.System.arraycopy() method copies a source array from a specific beginning position to the destination array from the mentioned position. No. of arguments to be copied are decided by len argument.

    The components at source_Position to source_Position + length – 1 are copied to destination array from destination_Position to destination_Position + length – 1.



    Class Declaration:

    public final class System extends Object
    

    Syntax:

    public static void arraycopy(Object source_arr, int sourcePos,
                                Object dest_arr, int destPos, int len)
    
    Parameters : 
    source_arr : array to be copied from
    sourcePos : starting position in source array from where to copy
    dest_arr : array to be copied in
    destPos : starting position in destination array, where to copy in
    len : total no. of components to be copied.
    

    Examples:

    Input : a[] = {1, 2, 3}
            b[] = {4, 5, 6}
    Output : {1, 2, 3, 4, 5, 6}
    
    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Java program to merge two arrays of 
    // same type into an Object array.
      
    import java.util.stream.Stream;
    import java.util.Arrays;
    import java.io.*;
      
    class GFG {
          
        // Function to merge two arrays of same type
        public static <T> Object[] concatenate(T[] a, T[] b)
        {
            // Create an empty Object array of the combined
            // size of the array a and array b
            Object[] n=new Object[a.length + b.length];
              
            // Copy the array a into n
            System.arraycopy(a, 0, n, 0, a.length);
              
            // Copy the array b into n
            System.arraycopy(b, 0, n, a.length, b.length);
              
            return n;
        }
          
        public static void main (String[] args) 
        {
            Integer[] a = new Integer[]{1,2,3};
            Integer[] b = new Integer[]{4,5,6};
          
            Object[] c = concatenate(a,b);
           
        System.out.println("Merged object array : "
                           + Arrays.toString(c));
        }
    }

    chevron_right

    
    

    Output:

    Merged object array : [1, 2, 3, 4, 5, 6]
    

  3. Java Collections: A Collection is a group of individual objects represented as a single unit. Java provides Collection Framework which defines several classes and interfaces to represent a group of objects as a single unit.

    • Using Java Collections for Java 8 Stream:
      Examples:

      Input : a[] = {1, 2, 3}
              b[] = {4, 5, 6}
      Output : {1, 2, 3, 4, 5, 6}
      
      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // Java program to merge two arrays of 
      // same type into an Object array.
        
      import java.util.stream.*;
      import java.util.Arrays;
      import java.io.*;
        
      class GFG {
        
          // Function to merge two arrays of same type
          public static <T> Object[] concatenate(T[] a, T[] b)
          {
                
              // Create an empty List of type Object
              List<Object> n = new ArrayList<>();
        
              // Add arrays to list
              Stream.of(a, b)
                   .flatMap(Stream::of)
                   .forEach(n::add);
                
              // Convert list to array and return
              return n.toArray();
          }
            
          public static void main (String[] args) 
          {
              Integer[] a = new Integer[]{1,2,3};
              Integer[] b = new Integer[]{4,5,6};
            
              Object[] c = concatenate(a,b);
                
        
          System.out.println("Merged object array : "
                             + Arrays.toString(c));
          }
      }

      chevron_right

      
      

      Output :

      Merged object array : [1, 2, 3, 4, 5, 6]
      

    • Using Java Collections for Java 7 using Collections.addAll():
      Examples:

      Input : a[] = {1, 2, 3}
              b[] = {4, 5, 6}
      Output : {1, 2, 3, 4, 5, 6}
      
      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // Java program to merge two arrays of 
      // same type into an Object array.
        
      import java.util.*;
      import java.io.*;
        
      class GFG {
        
          // Function to merge two arrays of same type
          public static <T> List<Object> concatenate(T[] a, T[] b)
          {
              // Create an empty List of type Object
              List<Object> n = new ArrayList<>();
                
              // Add the array a into n
              Collections.addAll(n, a);
                
              // Add the array b into n
              Collections.addAll(n, b);
                
              return n;
          }
            
          public static void main (String[] args) 
          {
              Integer[] a = new Integer[]{1,2,3};
              Integer[] b = new Integer[]{4,5,6};
                
              List<Object> c = concatenate(a,b);
            
              System.out.println("Merged object array : "
                                 + c);
          }
      }

      chevron_right

      
      

      Output :

      Merged object array : [1, 2, 3, 4, 5, 6]
      


My Personal Notes arrow_drop_up

Technical Content Engineer at GeeksForGeeks

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.