Comment concaténer deux tableaux en Java ?

Question

J'ai besoin de concaténer deux String tableaux en Java.

void f(String[] first, String[] second) {
    String[] both = ???
}

Quel est le moyen le plus simple de le faire ?

Answer 1

J'ai trouvé une solution en une ligne dans la bonne vieille bibliothèque Apache Commons Lang.
ArrayUtils.addAll(T[], T...)

Code :

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

Answer 2

Voici une méthode simple qui va concaténer deux tableaux et renvoyer le résultat :

public <T> T[] concatenate(T[] a, T[] b) {
    int aLen = a.length;
    int bLen = b.length;

    @SuppressWarnings("unchecked")
    T[] c = (T[]) Array.newInstance(a.getClass().getComponentType(), aLen + bLen);
    System.arraycopy(a, 0, c, 0, aLen);
    System.arraycopy(b, 0, c, aLen, bLen);

    return c;
}

Notez que cela ne fonctionnera pas avec les types de données primitifs, mais uniquement avec les types d'objets.

La version suivante, légèrement plus compliquée, fonctionne à la fois avec les tableaux d'objets et les tableaux primitifs. Pour ce faire, elle utilise T au lieu de T[] comme type d'argument.

Il permet également de concaténer des tableaux de deux types différents en choisissant le type le plus général comme type de composant du résultat.

public static <T> T concatenate(T a, T b) {
    if (!a.getClass().isArray() || !b.getClass().isArray()) {
        throw new IllegalArgumentException();
    }

    Class<?> resCompType;
    Class<?> aCompType = a.getClass().getComponentType();
    Class<?> bCompType = b.getClass().getComponentType();

    if (aCompType.isAssignableFrom(bCompType)) {
        resCompType = aCompType;
    } else if (bCompType.isAssignableFrom(aCompType)) {
        resCompType = bCompType;
    } else {
        throw new IllegalArgumentException();
    }

    int aLen = Array.getLength(a);
    int bLen = Array.getLength(b);

    @SuppressWarnings("unchecked")
    T result = (T) Array.newInstance(resCompType, aLen + bLen);
    System.arraycopy(a, 0, result, 0, aLen);
    System.arraycopy(b, 0, result, aLen, bLen);        

    return result;
}

Voici un exemple :

Assert.assertArrayEquals(new int[] { 1, 2, 3 }, concatenate(new int[] { 1, 2 }, new int[] { 3 }));
Assert.assertArrayEquals(new Number[] { 1, 2, 3f }, concatenate(new Integer[] { 1, 2 }, new Number[] { 3f }));

Answer 3

Utilisation de Stream en Java 8 :

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

Ou comme ceci, en utilisant flatMap :

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

Pour faire cela pour un type générique, vous devez utiliser la réflexion :

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

Answer 4

Il est possible d'écrire une version entièrement générique qui peut même être étendue pour concaténer un nombre quelconque de tableaux. Cette version nécessite Java 6, car elle utilise Arrays.copyOf()

Les deux versions évitent de créer tout intermédiaire List les objets et l'utilisation System.arraycopy() pour s'assurer que la copie de grands tableaux est aussi rapide que possible.

Pour deux tableaux, cela ressemble à ceci :

public static <T> T[] concat(T[] first, T[] second) {
  T[] result = Arrays.copyOf(first, first.length + second.length);
  System.arraycopy(second, 0, result, first.length, second.length);
  return result;
}

Et pour un nombre arbitraire de tableaux (>= 1), cela ressemble à ceci :

public static <T> T[] concatAll(T[] first, T[]... rest) {
  int totalLength = first.length;
  for (T[] array : rest) {
    totalLength += array.length;
  }
  T[] result = Arrays.copyOf(first, totalLength);
  int offset = first.length;
  for (T[] array : rest) {
    System.arraycopy(array, 0, result, offset, array.length);
    offset += array.length;
  }
  return result;
}

Answer 5

Ou avec le bien-aimé Goyave :

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

Il existe également des versions pour les tableaux primitifs :

• 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)