LinkedList oder ArrayList in Java: Was wählen und warum das wichtig ist

LinkedList oder ArrayList: Kampf der Giganten der Java-Collections

Wenn Sie jemals Java-Code geschrieben haben, der mit Datenlisten arbeitet, sind Sie sicherlich auf das Dilemma gestoßen: LinkedList oder ArrayList? Diese Frage ist ein echter Hit auf Stack Overflow, tausende Entwickler diskutieren darüber. Und das zu Recht. Die Wahl der falschen Datenstruktur kann Ihren schnellen Code in eine Schildkröte verwandeln, die durch den Sumpf kriecht. Die richtige Wahl hingegen kann Ihre Anwendung reaktionsschnell und effizient machen.

Heute werden wir nicht einfach trockene Fakten auflisten. Wir werfen einen Blick unter die Haube von Java, verstehen, wie diese Collections auf Speicher- und Prozessorebene funktionieren, und geben eine klare Antwort: Wann sollte man tatsächlich LinkedList und wann ArrayList verwenden? Los geht's!

Kurz zum Wesentlichen: Was die Herren aus der Dokumentation sagen

Beginnen wir mit den Grundlagen. Beide Klassen implementieren das Interface List, aber auf unterschiedliche Weise.

\n
• ArrayList ist ein dynamisches Array. Es speichert Elemente in einem zusammenhängenden Speicherblock. Wenn das Array voll ist, erstellt es ein neues, größeres Array und kopiert alle Elemente dorthin.
\n
• LinkedList ist eine doppelt verkettete Liste. Jedes Element (Knoten) speichert Verweise auf das vorherige und das nächste Element. Der Speicher wird für jeden Knoten separat zugewiesen.
\n

Klingt einfach. Aber der Teufel steckt, wie immer, im Detail. Schauen wir uns den Code an.

Unter der Haube: Wie es in der Praxis funktioniert

ArrayList: Schneller Zugriff, aber langsames Einfügen in die Mitte

import java.util.ArrayList;\nimport java.util.List;\n\npublic class ArrayListDemo {\n    public static void main(String[] args) {\n        List<String> arrayList = new ArrayList<>();\n        \n        // Hinzufügen am Ende — schnell (O(1) amortisiert)\n        long start = System.nanoTime();\n        for (int i = 0; i < 100000; i++) {\n            arrayList.add("Element " + i);\n        }\n        long end = System.nanoTime();\n        System.out.println("ArrayList add (am Ende): " + (end - start) / 1e6 + " ms");\n        \n        // Zugriff über Index — sofort (O(1))\n        start = System.nanoTime();\n        String element = arrayList.get(50000);\n        end = System.nanoTime();\n        System.out.println("ArrayList get: " + (end - start) + " ns");\n        \n        // Einfügen in die Mitte — langsam (O(n))\n        start = System.nanoTime();\n        arrayList.add(25000, "INSERTED");\n        end = System.nanoTime();\n        System.out.println("ArrayList insert (Mitte): " + (end - start) / 1e6 + " ms");\n    }\n}

Was passiert hier? Wenn Sie ein Element in die Mitte einer ArrayList einfügen, werden alle Elemente rechts von der Einfügestelle um eine Position verschoben. Dies ist eine O(n)-Operation. Wenn Sie eine Million Elemente haben, sind das eine Million Kopiervorgänge. Schmerzhaft.

LinkedList: Einfügen ist König, aber Zugriff ist der Außenseiter

import java.util.LinkedList;\nimport java.util.List;\n\npublic class LinkedListDemo {\n    public static void main(String[] args) {\n        List<String> linkedList = new LinkedList<>();\n        \n        // Hinzufügen am Ende — schnell (O(1))\n        long start = System.nanoTime();\n        for (int i = 0; i < 100000; i++) {\n            linkedList.add("Element " + i);\n        }\n        long end = System.nanoTime();\n        System.out.println("LinkedList add (am Ende): " + (end - start) / 1e6 + " ms");\n        \n        // Zugriff über Index — langsam (O(n))\n        start = System.nanoTime();\n        String element = linkedList.get(50000);\n        end = System.nanoTime();\n        System.out.println("LinkedList get: " + (end - start) / 1e6 + " ms");\n        \n        // Einfügen in die Mitte — schnell (O(1) nach der Positionssuche)\n        start = System.nanoTime();\n        // ACHTUNG: Die Methode add(index, element) selbst führt trotzdem eine Suche durch (O(n))\n        linkedList