这是算盘常用的密码。

String[] a = {"a", "b", "c"};
String[] b = {"1", "2", "3"};
String[] c = N.concat(a, b); // c = ["a", "b", "c", "1", "2", "3"]

// N.concat(...) is null-safety.
a = null;
c = N.concat(a, b); // c = ["1", "2", "3"]

这里是silvertab解决方案的一个修改，对泛型进行了改进：

static <T> T[] concat(T[] a, T[] b) {
    final int alen = a.length;
    final int blen = b.length;
    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;
}

注意：请参阅Joachim的Java 6解决方案答案。它不仅消除了警告；它也更短，更高效，更容易阅读！

看看这个优雅的解决方案（如果您需要除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;
    }
}

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

简单一点怎么样

public static class Array {

    public static <T> T[] concat(T[]... arrays) {
        ArrayList<T> al = new ArrayList<T>();
        for (T[] one : arrays)
            Collections.addAll(al, one);
        return (T[]) al.toArray(arrays[0].clone());
    }
}

只需执行Array.concat（arr1，arr2）。只要arr1和arr2是相同类型的，这将为您提供另一个包含这两个数组的相同类型的数组。

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

代码：

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

另一种思考问题的方式。要连接两个或多个数组，必须列出每个数组的所有元素，然后构建一个新数组。这听起来像是创建一个List＜T＞，然后调用它上的Array。其他一些答案使用ArrayList，这很好。但如何实现我们自己的呢？这并不难：

private static <T> T[] addAll(final T[] f, final T...o){
    return new AbstractList<T>(){

        @Override
        public T get(int i) {
            return i>=f.length ? o[i - f.length] : f[i];
        }

        @Override
        public int size() {
            return f.length + o.length;
        }

    }.toArray(f);
}

我相信上面的解决方案相当于使用System.arraycopy的解决方案。然而，我认为这个解决方案有其自身的优点。