给定两个相同类型的数组，它们需要合并到一个新的对象数组中。任务是将两个相同类型的数组合并为一个对象数组，以使数组元素在新合并的数组中保持其原始顺序，并且第一个数组的元素在合并的对象数组中位于第二个数组的元素之前。
可以通过Java中的许多方式来完成此合并，例如Java8的System.arrraycopy()和Java Collections。

1. Java 8：在Java8中，可以使用Stream API来完成。
   • 使用Stream.of()，flatMap()和toArray()方法：
     Stream的类层次结构：

     java.lang.Object
       ↳Java.util.stream

     方法说明

     修饰符和类型	方法	描述
     static Stream	of(T… values)	返回元素为指定值的有序流。
     Stream	flatMap(Function mapper)	在每个元素上应用了映射功能之后，返回对象流，然后展平结果。
     Object[]	toArray()	返回包含此流元素的数组。

     例子：

     输入：a [] = {1,2,3}
             b [] = {4，5，6}
     输出：{1,2,3,4,5,6}

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

     // Java展示把类型相同的数组合并到一个Object array.
     import java.util.stream.Stream;
     import java.util.Arrays;
     import java.io.*;
     class GFG {
         public static  Object[] concatenate(T[] a, T[] b)
         {
             // 合并类型相同的数组的函数
             return Stream.of(a, b)
                          .flatMap(Stream::of)
                          .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("合并的object array : "
                            + Arrays.toString(c));
         }
     }

     输出：

     合并的object array : [1, 2, 3, 4, 5, 6]
     

   • 使用Stream.concat()，Arrays.stream()和toArray()方法：

     方法说明

     修饰符和类型	方法	描述
     static Stream	concat(Stream a, Stream b)	创建一个延迟串联的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。

     例子：

     输入：a [] = {1,2,3}
             b [] = {4，5，6}
     输出：{1,2,3,4,5,6}

     说明：
     Stream.concat()创建一个合并的流，其中元素按照它们在参数中的顺序排列。在这里，Stream.concat()创建一个级联流，其元素是从数组’a’转换的流的所有元素，然后加上从数组’b’转换的流的所有元素。然后将串联的流转换为数组并返回。

     // Java合并两个数组到一个Object array.
     import java.util.stream.Stream;
     import java.util.Arrays;
     import java.io.*;
     class GFG {
         public static  Object[] concatenate(T[] a, T[] b)
         {
             // 合并函数
             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("合并的数组 : "
                            + Arrays.toString(c));
         }
     }

     输出：

     合并的数组 : [1, 2, 3, 4, 5, 6]
     

      

2. System.arraycopy()：java.lang.System.arraycopy()方法将源数组从特定的开始位置复制到目标位置(从提到的位置开始)。要复制的数量由len参数决定。将source_Position到source_Position + length – 1的数组复制到目标数组的destination_Position到destination_Position + length – 1。
   类声明：

   public final class System extends Object

   语法：

   public static void arraycopy(Object source_arr, int sourcePos,
                               Object dest_arr, int destPos, int len)

   参数：

   source_arr : 有待复制的数组
   sourcePos : source_arr中开始copy的index
   dest_arr : 待并入数组
   destPos : dest_arr中开始并入的index
   len : 需要被copy的子数组长度.

   例子：

   输入：a [] = {1,2,3}
           b [] = {4，5，6}
   输出：{1,2,3,4,5,6}

   // Java 展示合并数组
   import java.util.stream.Stream;
   import java.util.Arrays;
   import java.io.*;
   class GFG {
       // 合并数组函数
       public static  Object[] concatenate(T[] a, T[] b)
       {
           // 创建一个合并后的数组
           Object[] n=new Object[a.length + b.length];
           // 把a拷贝到n
           System.arraycopy(a, 0, n, 0, a.length);
           // 把b拷贝到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("合并后的数组 : "
                          + Arrays.toString(c));
       }
   }

   输出：

   合并后的数组 : [1, 2, 3, 4, 5, 6]

3. Java集合Collection：集合是一组表示为单个单元的单个对象。Java提供了Collection Framework，它定义了几个类和接口来将一组对象表示为一个单元。
   • 将Java集合用于Java 8 Stream：
     示例：输入：a [] = {1,2,3}
     b [] = {4，5，6}输出：{1,2,3,4,5,6}

     // Java展示合并数组
     import java.util.stream.*;
     import java.util.Arrays;
     import java.io.*;
     class GFG {
         // 合并数组的函数
         public static  Object[] concatenate(T[] a, T[] b)
         {
             // 创建一个空的List，类型为Object
             List