public static String[] toArray(String[]... object){
    List<String> list=new ArrayList<>();
    for (String[] i : object) {
        list.addAll(Arrays.asList(i));
    }
    return list.toArray(new String[list.size()]);
}

一个与类型无关的变体（已更新-感谢Volley实例化T）：

@SuppressWarnings("unchecked")
public static <T> T[] join(T[]...arrays) {

    final List<T> output = new ArrayList<T>();

    for(T[] array : arrays) {
        output.addAll(Arrays.asList(array));
    }

    return output.toArray((T[])Array.newInstance(
        arrays[0].getClass().getComponentType(), output.size()));
}

这里是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解决方案答案。它不仅消除了警告；它也更短，更高效，更容易阅读！

在Java 8中使用流：

String[] both = Stream.concat(Arrays.stream(a), Arrays.stream(b))
                      .toArray(String[]::new);

或者像这样，使用flatMap：

String[] both = Stream.of(a, b).flatMap(Stream::of)
                      .toArray(String[]::new);

要对泛型类型执行此操作，必须使用反射：

@SuppressWarnings("unchecked")
T[] both = Stream.concat(Arrays.stream(a), Arrays.stream(b)).toArray(
    size -> (T[]) Array.newInstance(a.getClass().getComponentType(), size));

用lambda连接一系列紧凑、快速且类型安全的数组

@SafeVarargs
public static <T> T[] concat( T[]... arrays ) {
  return( Stream.of( arrays ).reduce( ( arr1, arr2 ) -> {
      T[] rslt = Arrays.copyOf( arr1, arr1.length + arr2.length );
      System.arraycopy( arr2, 0, rslt, arr1.length, arr2.length );
      return( rslt );
    } ).orElse( null ) );
};

在没有参数的情况下调用时返回null

例如，具有3个阵列：

String[] a = new String[] { "a", "b", "c", "d" };
String[] b = new String[] { "e", "f", "g", "h" };
String[] c = new String[] { "i", "j", "k", "l" };

concat( a, b, c );  // [a, b, c, d, e, f, g, h, i, j, k, l]

“……可能是唯一通用和类型安全的方法”–适用于：

Number[] array1 = { 1, 2, 3 };
Number[] array2 = { 4.0, 5.0, 6.0 };
Number[] array = concat( array1, array2 );  // [1, 2, 3, 4.0, 5.0, 6.0]

我看到许多带有公共静态T[]concat（T[]a，T[]b）｛｝等签名的通用答案，但据我所知，这些答案只适用于Object数组，而不适用于基元数组。下面的代码既适用于对象数组，也适用于基元数组，使其更通用。。。

public static <T> T concat(T a, T b) {
        //Handles both arrays of Objects and primitives! E.g., int[] out = concat(new int[]{6,7,8}, new int[]{9,10});
        //You get a compile error if argument(s) not same type as output. (int[] in example above)
        //You get a runtime error if output type is not an array, i.e., when you do something like: int out = concat(6,7);
        if (a == null && b == null) return null;
        if (a == null) return b;
        if (b == null) return a;
        final int aLen = Array.getLength(a);
        final int bLen = Array.getLength(b);
        if (aLen == 0) return b;
        if (bLen == 0) return a;
        //From here on we really need to concatenate!

        Class componentType = a.getClass().getComponentType();
        final T result = (T)Array.newInstance(componentType, aLen + bLen);
        System.arraycopy(a, 0, result, 0, aLen);
        System.arraycopy(b, 0, result, aLen, bLen);
        return result;
    }

    public static void main(String[] args) {
        String[] out1 = concat(new String[]{"aap", "monkey"}, new String[]{"rat"});
        int[] out2 = concat(new int[]{6,7,8}, new int[]{9,10});
    }