在Java中将数组合并成一个新的对象数组

给定两个相同类型的数组，需要将它们合并成一个新的对象数组。任务是将两个相同类型的数组合并为一个对象数组，使得数组元素在新合并的数组中保持其原始顺序，并且第一个数组的元素在合并的对象数组中位于第二个数组的元素之前。

这种合并可以在Java中的许多方法中完成，例如 Java8、System.arraycopy() 和Java集合。

将数组合并为新对象的不同方法

在Java 8 中使用 Stream API 并使用 Stream.of()、flatMap() 和 toArray() 方法
使用 concat() 方法 Stream 类
使用 System 类的 arraycopyOf() 方法
为Java 8 及更高版本使用Java集合
为Java 7 使用Java集合

让我们详细讨论这些方法，如下所示：

方法 1：使用 Java8 中的 Stream API 并使用 Stream.of()、flatMap() 和 toArray() 方法

Stream的类层次结构如下：

java.lang.Object
  ↳  java.util.stream

Method	Action Performed
of(T… values)	Returns a sequential ordered stream whose elements are the specified values.
flatMap(Function mapper)	Returns a stream of objects after applying the mapping function on each element and then flattens the result.
toArray()	Returns an array containing the elements of this stream.

插图：

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

Output : {1, 2, 3, 4, 5, 6}

输出说明： Stream.of(a, b) 获取数组并将它们通过管道传输到单个流中。然后 flatMap() 方法在对 Stream.of() 的每个元素应用映射函数后返回一个对象流，然后将结果展平。最后， toArray() 将流元素转换为数组并返回形成的数组。

例子：

Java

// 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  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));
    }
}

Java

// 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  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));
    }
}

Java

// 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  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));
    }
}

Java

// 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  Object[] concatenate(T[] a, T[] b)
    {
         
        // Create an empty List of type Object
        List