这可能是唯一通用且类型安全的方法：

public class ArrayConcatenator<T> {
    private final IntFunction<T[]> generator;

    private ArrayConcatenator(IntFunction<T[]> generator) {
        this.generator = generator;
    }

    public static <T> ArrayConcatenator<T> concat(IntFunction<T[]> generator) {
        return new ArrayConcatenator<>(generator);
    }

    public T[] apply(T[] array1, T[] array2) {
        T[] array = generator.apply(array1.length + array2.length);
        System.arraycopy(array1, 0, array, 0, array1.length);
        System.arraycopy(array2, 0, array, array1.length, array2.length);
        return array;
    }
}

用法非常简洁：

Integer[] array1 = { 1, 2, 3 };
Double[] array2 = { 4.0, 5.0, 6.0 };
Number[] array = concat(Number[]::new).apply(array1, array2);

（需要静态导入）

拒绝无效的数组类型：

concat(String[]::new).apply(array1, array2); // error
concat(Integer[]::new).apply(array1, array2); // error

以下是对我有用的：

String[] data=null;
String[] data2=null;
ArrayList<String> data1 = new ArrayList<String>();
for(int i=0; i<2;i++) {
   data2 = input.readLine().split(",");
   data1.addAll(Arrays.asList(data2));
   data= data1.toArray(new String[data1.size()]);
   }

这里是silvertab编写的伪代码解决方案的工作代码中的一个可能实现。

谢谢silvertab！

public class Array {

   public static <T> T[] concat(T[] a, T[] b, ArrayBuilderI<T> builder) {
      T[] c = builder.build(a.length + b.length);
      System.arraycopy(a, 0, c, 0, a.length);
      System.arraycopy(b, 0, c, a.length, b.length);
      return c;
   }
}

接下来是构建器界面。

注意：构建器是必要的，因为在java中不可能这样做

新T[尺寸]

由于通用类型擦除：

public interface ArrayBuilderI<T> {

   public T[] build(int size);
}

这里是一个实现接口的具体构建器，构建一个整数数组：

public class IntegerArrayBuilder implements ArrayBuilderI<Integer> {

   @Override
   public Integer[] build(int size) {
      return new Integer[size];
   }
}

最后是应用程序/测试：

@Test
public class ArrayTest {

   public void array_concatenation() {
      Integer a[] = new Integer[]{0,1};
      Integer b[] = new Integer[]{2,3};
      Integer c[] = Array.concat(a, b, new IntegerArrayBuilder());
      assertEquals(4, c.length);
      assertEquals(0, (int)c[0]);
      assertEquals(1, (int)c[1]);
      assertEquals(2, (int)c[2]);
      assertEquals(3, (int)c[3]);
   }
}

我从老的Apache Commons Lang库中找到了一个单行解决方案。ArrayUtils.addAll（T[]，T…）

代码：

String[] both = ArrayUtils.addAll(first, second);

看看这个优雅的解决方案（如果您需要除char以外的其他类型，请更改它）：

private static void concatArrays(char[] destination, char[]... sources) {
    int currPos = 0;
    for (char[] source : sources) {
        int length = source.length;
        System.arraycopy(source, 0, destination, currPos, length);
        currPos += length;
    }
}

您可以连接每个数组计数。

我最近一直在与过度的记忆循环作斗争。如果已知a和/或b通常是空的，这里是silvertab代码的另一种修改（也被通用化）：

private static <T> T[] concatOrReturnSame(T[] a, T[] b) {
    final int alen = a.length;
    final int blen = b.length;
    if (alen == 0) {
        return b;
    }
    if (blen == 0) {
        return a;
    }
    final T[] result = (T[]) java.lang.reflect.Array.
            newInstance(a.getClass().getComponentType(), alen + blen);
    System.arraycopy(a, 0, result, 0, alen);
    System.arraycopy(b, 0, result, alen, blen);
    return result;
}

编辑：这篇文章的前一个版本指出，像这样的数组重用应该清楚地记录下来。正如Maarten在评论中指出的那样，一般来说，最好删除if语句，这样就不需要文档了。但话说回来，那些if语句首先就是这个特定优化的要点。我会在这里留下这个答案，但要小心！