Wie kann ich zwei Arrays in Java miteinander verknüpfen?

Question

Ich muss zwei Dateien verketten String Arrays in Java.

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

Wie lässt sich dies am einfachsten bewerkstelligen?

Answer 1

Ich habe eine einzeilige Lösung aus der guten alten Apache Commons Lang Bibliothek gefunden.
ArrayUtils.addAll(T[], T...)

Code:

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

Answer 2

Hier ist eine einfache Methode, die zwei Arrays miteinander verknüpft und das Ergebnis zurückgibt:

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

Beachten Sie, dass dies nicht mit primitiven Datentypen funktioniert, sondern nur mit Objekttypen.

Die folgende, etwas kompliziertere Version funktioniert sowohl mit Objekt- als auch mit primitiven Arrays. Sie tut dies durch die Verwendung von T anstelle von T[] als Argumenttyp.

Es ermöglicht auch die Verkettung von Arrays zweier unterschiedlicher Typen, indem der allgemeinste Typ als Komponententyp des Ergebnisses gewählt wird.

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

Hier ist ein Beispiel:

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

Verwendung von Stream in Java 8:

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

Oder so, mit flatMap :

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

Um dies für einen generischen Typ zu tun, müssen Sie Reflexion verwenden:

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

Answer 4

Es ist möglich, eine vollständig generische Version zu schreiben, die sogar erweitert werden kann, um eine beliebige Anzahl von Arrays zu verketten. Diese Versionen benötigen Java 6, da sie Arrays.copyOf()

Beide Versionen vermeiden die Schaffung von Zwischenschritten List Objekte und verwenden System.arraycopy() um sicherzustellen, dass das Kopieren großer Arrays so schnell wie möglich erfolgt.

Bei zwei Arrays sieht das so aus:

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

Und für eine beliebige Anzahl von Arrays (>= 1) sieht es wie folgt aus:

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

Oder mit der Geliebten Guave :

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

Außerdem gibt es Versionen für primitive Arrays:

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