用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]

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

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

Object[] obj = {"hi","there"};
Object[] obj2 ={"im","fine","what abt u"};
Object[] obj3 = new Object[obj.length+obj2.length];

for(int i =0;i<obj3.length;i++)
    obj3[i] = (i<obj.length)?obj[i]:obj2[i-obj.length];

非Java 8解决方案：

public static int[] combineArrays(int[] a, int[] b) {
        int[] c = new int[a.length + b.length];

        for (int i = 0; i < a.length; i++) {
            c[i] = a[i];
        }

        for (int j = 0, k = a.length; j < b.length; j++, k++) {
            c[k] = b[j];
        }

        return c;
    }

 /**
     * With Java Streams
     * @param first First Array
     * @param second Second Array
     * @return Merged Array
     */
    String[] mergeArrayOfStrings(String[] first, String[] second) {
        return Stream.concat(Arrays.stream(first), Arrays.stream(second)).toArray(String[]::new);
    }

FunctionalJava库有一个数组包装器类，它为数组提供了方便的方法，如串联。

import static fj.data.Array.array;

…然后

Array<String> both = array(first).append(array(second));

要取回展开的数组，请调用

String[] s = both.array();