如何在Java中连接两个数组？

Java 8中的单线程:

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

要么:

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

或者与心爱的番石榴:

String[] both = ObjectArrays.concat(first, second, String.class);

此外,还有原始数组的版本:

Booleans.concat(first, second)

Bytes.concat(first, second)

Chars.concat(first, second)

Doubles.concat(first, second)

Shorts.concat(first, second)

Ints.concat(first, second)

Longs.concat(first, second)

Floats.concat(first, second)

使用Java API:

String[] f(String[] first, String[] second) {
    List both = new ArrayList(first.length + second.length);
    Collections.addAll(both, first);
    Collections.addAll(both, second);
    return both.toArray(new String[both.size()]);
}

您可以将这两个数组附加到两行代码中.

String[] both = Arrays.copyOf(first, first.length + second.length);
System.arraycopy(second, 0, both, first.length, second.length);

这是一种快速有效的解决方案,适用于原始类型,并且所涉及的两种方法都是重载的.

您应该避免涉及ArrayLists,流等的解决方案,因为这些解决方案需要分配临时内存而没有用处.

您应该避免for大型数组的循环,因为这些循环效率不高.内置方法使用极快的块复制功能.

一个100%的旧java和没有 解决方案System.arraycopy(例如在GWT客户端中不可用):

static String[] concat(String[]... arrays) {
    int length = 0;
    for (String[] array : arrays) {
        length += array.length;
    }
    String[] result = new String[length];
    int pos = 0;
    for (String[] array : arrays) {
        for (String element : array) {
            result[pos] = element;
            pos++;
        }
    }
    return result;
}

我最近在内存轮换过多的情况下遇到了问题.如果已知a和/或b通常是空的,那么这是另一个silvertab代码的修改(也是通用的):

private static  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;
}

(在任何一种情况下,数组重用行为都应该是明确的JavaDoced!)

的功能的Java库具有装备有方便的方法,如级联阵列的阵列包装类.

import static fj.data.Array.array;

...然后

Array both = array(first).append(array(second));

要取出展开的阵列,请致电

String[] s = both.array();

ArrayList both = new ArrayList(Arrays.asList(first));
both.addAll(Arrays.asList(second));

both.toArray(new String[0]);

这是对silvertab解决方案的改编,改进了仿制药:

static  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解决方案的回答.它不仅消除了警告; 它也更短,更高效,更容易阅读!

Java8使用Stream的另一种方式

  public String[] concatString(String[] a, String[] b){ 
    Stream streamA = Arrays.stream(a);
    Stream streamB = Arrays.stream(b);
    return Stream.concat(streamA, streamB).toArray(String[]::new); 
  }

如果您使用这种方式,则无需导入任何第三方类.

如果你想连接 String

用于连接两个String Array的示例代码

public static String[] combineString(String[] first, String[] second){
        int length = first.length + second.length;
        String[] result = new String[length];
        System.arraycopy(first, 0, result, 0, first.length);
        System.arraycopy(second, 0, result, first.length, second.length);
        return result;
    }

如果你想连接 Int

用于连接两个整数数组的示例代码

public static int[] combineInt(int[] a, int[] b){
        int length = a.length + b.length;
        int[] result = new int[length];
        System.arraycopy(a, 0, result, 0, a.length);
        System.arraycopy(b, 0, result, a.length, b.length);
        return result;
    }

这是Main方法

    public static void main(String[] args) {

            String [] first = {"a", "b", "c"};
            String [] second = {"d", "e"};

            String [] joined = combineString(first, second);
            System.out.println("concatenated String array : " + Arrays.toString(joined));

            int[] array1 = {101,102,103,104};
            int[] array2 = {105,106,107,108};
            int[] concatenateInt = combineInt(array1, array2);

            System.out.println("concatenated Int array : " + Arrays.toString(concatenateInt));

        }
    }  

我们也可以用这种方式.

请原谅我在这个已经很久的列表中添加了另一个版本.我查看了每个答案,并决定我真的想要一个只有一个参数的签名版本.我还添加了一些参数检查,以便在意外输入的情况下通过合理的信息从早期故障中受益.

@SuppressWarnings("unchecked")
public static  T[] concat(T[]... inputArrays) {
  if(inputArrays.length < 2) {
    throw new IllegalArgumentException("inputArrays must contain at least 2 arrays");
  }

  for(int i = 0; i < inputArrays.length; i++) {
    if(inputArrays[i] == null) {
      throw new IllegalArgumentException("inputArrays[" + i + "] is null");
    }
  }

  int totalLength = 0;

  for(T[] array : inputArrays) {
    totalLength += array.length;
  }

  T[] result = (T[]) Array.newInstance(inputArrays[0].getClass().getComponentType(), totalLength);

  int offset = 0;

  for(T[] array : inputArrays) {
    System.arraycopy(array, 0, result, offset, array.length);

    offset += array.length;
  }

  return result;
}

您可以尝试将其转换为Arraylist并使用addAll方法然后转换回数组.

List list = new ArrayList(Arrays.asList(first));
  list.addAll(Arrays.asList(second));
  String[] both = list.toArray();

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

谢谢silvertab!

public class Array {

   public static  T[] concat(T[] a, T[] b, ArrayBuilderI 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;
   }
}

public interface ArrayBuilderI {

   public T[] build(int size);
}

public class IntegerArrayBuilder implements ArrayBuilderI {

   @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]);
   }
}

private static String[] concatArrays(final String[]... arrays) {
    return Arrays.stream(arrays)
         .flatMap(Arrays::stream)
         .toArray(String[]::new);
}

public class StringConcatenate {

    public static void main(String[] args){

        // Create two arrays to concatenate and one array to hold both
        String[] arr1 = new String[]{"s","t","r","i","n","g"};
        String[] arr2 = new String[]{"s","t","r","i","n","g"};
        String[] arrBoth = new String[arr1.length+arr2.length];

        // Copy elements from first array into first part of new array
        for(int i = 0; i < arr1.length; i++){
            arrBoth[i] = arr1[i];
        }

        // Copy elements from second array into last part of new array
        for(int j = arr1.length;j < arrBoth.length;j++){
            arrBoth[j] = arr2[j-arr1.length];
        }

        // Print result
        for(int k = 0; k < arrBoth.length; k++){
            System.out.print(arrBoth[k]);
        }

        // Additional line to make your terminal look better at completion!
        System.out.println();
    }
}

String [] arg1 = new String{"a","b","c"};
String [] arg2 = new String{"x","y","z"};

ArrayList temp = new ArrayList();
temp.addAll(Arrays.asList(arg1));
temp.addAll(Arrays.asList(arg2));
String [] concatedArgs = temp.toArray(new String[arg1.length+arg2.length]);

public String [] concatenate (final String array1[], final String array2[])
{
    return Stream.concat(Stream.of(array1), Stream.of(array2)).toArray(String[]::new);
}

public String[] mergeArrays(String[] mainArray, String[] addArray) {
    String[] finalArray = new String[mainArray.length + addArray.length];
    System.arraycopy(mainArray, 0, finalArray, 0, mainArray.length);
    System.arraycopy(addArray, 0, finalArray, mainArray.length, addArray.length);

    return finalArray;
}

public static class Array {

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