Effiziente Array-Verkettung in Java

Java bietet keine eingebaute Operation zum Verketten von Arrays. Da Arrays eine feste Größe haben, erfordert die Kombination zweier Arrays die Erstellung eines neuen, größeren Arrays und das Kopieren der Elemente. Dieser Artikel untersucht drei effektive Methoden, um dies zu erreichen.

Inhaltsverzeichnis

• Verwendung von Apache Commons Langs addAll()
• Verwendung von System.arraycopy()
• Manuelle Verkettung mit Schleifen

Verwendung von Apache Commons Langs addAll()

Die Apache Commons Lang Bibliothek bietet die komfortable addAll() Methode innerhalb ihrer ArrayUtils Klasse. Dies vereinfacht die Array-Verkettung erheblich. Fügen Sie zunächst die Abhängigkeit zu Ihrem Projekt hinzu (z. B. mit Maven):

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version> <!-- Verwenden Sie die neueste Version -->
</dependency>

Verwenden Sie es dann wie folgt:

import org.apache.commons.lang3.ArrayUtils;

public class ArrayConcatenation {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};

        int[] concatenatedArray = ArrayUtils.addAll(array1, array2);

        for (int i : concatenatedArray) {
            System.out.print(i + " "); // Ausgabe: 1 2 3 4 5 6
        }
    }
}

Dieser Ansatz ist sauber und effizient, führt aber eine externe Abhängigkeit ein.

Verwendung von System.arraycopy()

Javas eingebautes System.arraycopy() bietet eine native Lösung. Diese Methode kopiert einen Teil eines Arrays in ein anderes. Sie erfordert die manuelle Array-Erstellung und Indexverwaltung:

public class ArrayConcatenation {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};

        int[] concatenatedArray = new int[array1.length + array2.length];

        System.arraycopy(array1, 0, concatenatedArray, 0, array1.length);
        System.arraycopy(array2, 0, concatenatedArray, array1.length, array2.length);

        for (int i : concatenatedArray) {
            System.out.print(i + " "); // Ausgabe: 1 2 3 4 5 6
        }
    }
}

Diese Methode ist effizient und vermeidet externe Bibliotheken, ist aber weniger prägnant.

Manuelle Verkettung mit Schleifen

Ein expliziterer, wenn auch weniger effizienter Ansatz beinhaltet die Iteration durch beide Arrays und das Auffüllen eines neuen Arrays:

public class ArrayConcatenation {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};

        int[] concatenatedArray = new int[array1.length + array2.length];

        for (int i = 0; i < array1.length; i++) {
            concatenatedArray[i] = array1[i];
        }
        for (int i = 0; i < array2.length; i++) {
            concatenatedArray[array1.length + i] = array2[i];
        }

        for (int i : concatenatedArray) {
            System.out.print(i + " "); // Ausgabe: 1 2 3 4 5 6
        }
    }
}

Diese Methode ist unkompliziert und leicht verständlich, daher eignet sie sich für Anfänger. Sie ist jedoch weniger effizient als die anderen Methoden, insbesondere bei großen Arrays.

Der optimale Ansatz hängt von Ihren Prioritäten ab: addAll() bietet Prägnanz, arraycopy() bietet Effizienz ohne externe Bibliotheken und die manuelle Schleife bietet Klarheit. Passen Sie den Code für verschiedene Array-Typen an (z. B. String[], double[]).