Java Academy · Les

LinkedList versus ArrayList: afwegingen

Vergelijk de prestaties van invoegen, verwijderen en directe toegang om het juiste lijsttype te kiezen.

Les 3 van 413 stappen

LinkedList versus ArrayList: afwegingen is een gratis Java Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.

De kernvraag

Zowel ArrayList als LinkedList implementeren List, dus ze hebben dezelfde API. Het verschil zit in hun interne gegevensstructuren en de bewerkingen die elke structuur efficiënt uitvoert.

Interne werking van ArrayList

ArrayList slaat elementen op in een aaneengesloten array. Wanneer de array vol raakt, wordt deze vervangen door een nieuwe array die 1,5 keer zo groot is en worden alle elementen gekopieerd.

import java.util.ArrayList;

ArrayList<String> list = new ArrayList<>(4); // initial capacity 4
list.add("A"); list.add("B"); list.add("C"); list.add("D");
list.add("E"); // triggers resize: new array of capacity 6

System.out.println(list.get(3)); // O(1) — direct index access

Interne werking van LinkedList opnieuw bekeken

Elk element bevindt zich in een eigen Node-object met prev/next-verwijzingen. Er is geen aaneengesloten geheugen — knooppunten kunnen overal op de heap staan.

import java.util.LinkedList;

LinkedList<String> list = new LinkedList<>();
list.add("A"); list.add("B"); list.add("C");

// get(index) must traverse from head or tail
System.out.println(list.get(1)); // O(n) — traverses 1 step from head

Willekeurige toegang: ArrayList wint

ArrayList.get(i) is O(1) — directe toegang via de array-index. LinkedList.get(i) is O(n) — er worden maximaal n/2 knooppunten doorlopen.

ArrayList<Integer> al = new ArrayList<>();
LinkedList<Integer> ll = new LinkedList<>();
for (int i = 0; i < 100_000; i++) { al.add(i); ll.add(i); }

// Fast:
System.out.println(al.get(99_999)); // O(1)

// Slow — avoid this pattern with LinkedList:
System.out.println(ll.get(99_999)); // O(n)

Invoegen aan het begin: LinkedList wint

Toevoegen op index 0 in ArrayList vereist het verschuiven van alle elementen — O(n). LinkedList werkt slechts twee verwijzingen bij — O(1).

// ArrayList: O(n) — shifts all elements right
ArrayList<String> al = new ArrayList<>(List.of("B","C","D"));
al.add(0, "A"); // shifts B, C, D

// LinkedList: O(1)
LinkedList<String> ll = new LinkedList<>(List.of("B","C","D"));
ll.addFirst("A"); // updates head pointer only

Invoegen aan het einde: ongeveer gelijk

Zowel ArrayList als LinkedList bieden geamortiseerde O(1)-toevoegingen aan het einde. ArrayList start af en toe een kopieerbewerking voor het vergroten van de array, maar geamortiseerd blijft de bewerking O(1). LinkedList maakt een nieuw knooppunt — vergroten is niet nodig.

ArrayList<Integer> al = new ArrayList<>();
LinkedList<Integer> ll = new LinkedList<>();

for (int i = 0; i < 1_000_000; i++) {
    al.add(i); // amortized O(1)
    ll.add(i); // O(1)
}

Geheugengebruik

ArrayList: ongeveer 8 bytes per element, één verwijzing in de array. LinkedList: ongeveer 48 bytes per element, een Node-object met data, prev, next en de objectheader. Voor grote gegevensverzamelingen gebruikt ArrayList aanzienlijk minder geheugen.

Prestaties bij doorlopen

Sequentieel doorlopen, met for-each of een iterator, is voor beide O(n). ArrayList profiteert echter van vooraf ophalen door de CPU-cache — elementen staan aaneengesloten in het geheugen. De knooppunten van LinkedList zijn verspreid over de heap, wat cachemissers veroorzaakt.

// Both O(n), but ArrayList is faster in practice due to cache locality
for (String s : arrayList) { process(s); }
for (String s : linkedList) { process(s); } // more cache misses

Invoegen/verwijderen in het midden

Bij beide is O(n) nodig om de positie te vinden. Eenmaal gevonden verschuift ArrayList elementen in O(n), terwijl LinkedList ze in O(1) loskoppelt. Bij vaak wijzigen in het midden wint LinkedList dus wanneer je al een iterator hebt; anders zijn ze vergelijkbaar.

LinkedList<Integer> ll = new LinkedList<>(List.of(1,2,3,4,5));
ListIterator<Integer> it = ll.listIterator();
while (it.hasNext()) {
    int val = it.next();
    if (val == 3) it.remove(); // O(1) unlink via iterator
}
System.out.println(ll); // [1, 2, 4, 5]

Keuzehulp

Kies op basis van de bewerking die je het vaakst uitvoert:

ArrayList: willekeurige toegang, doorlopen en toevoegen aan het einde — geschikt voor 90% van de toepassingen
LinkedList: vaak invoegen of verwijderen aan het begin of einde, en een wachtrij, Deque of stapel implementeren
ArrayDeque: wanneer je een pure wachtrij of stapel nodig hebt, omdat deze beter is dan LinkedList

Samenvatting van de benchmark

Denkmodel voor prestaties:

get(i): ArrayList O(1) tegenover LinkedList O(n)
add(0,x): ArrayList O(n) tegenover LinkedList O(1)
add(x): beide geamortiseerd O(1)
verwijderen via een iterator: beide O(1) zodra de juiste positie is bereikt
Geheugen per element: ArrayList ongeveer 8 B tegenover LinkedList ongeveer 48 B

Korte controle

Je bouwt een taakwachtrij waarin taken miljoenen keren per seconde aan het einde worden toegevoegd en aan het begin verwijderd. Welke datastructuur is het meest geschikt?

Beantwoord dit in de interactieve les

Samenvatting: LinkedList versus ArrayList

Belangrijkste punten:

ArrayList blinkt uit in willekeurige toegang (O(1)) en iteratie die cachevriendelijk is
LinkedList blinkt uit in O(1)-bewerkingen aan het begin en einde
Geheugen: ArrayList ~8 B/element; LinkedList ~48 B/element
Gebruik voor wachtrijen en stacks bij voorkeur ArrayDeque in plaats van LinkedList
ArrayList is voor de meeste scenario's de juiste standaardkeuze

Gratis beginnen

Leer Java met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 104
Lessen: 374

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “LinkedList versus ArrayList: afwegingen” gratis?

Ja — de volledige tekst van “LinkedList versus ArrayList: afwegingen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.

Wat leer ik in “LinkedList versus ArrayList: afwegingen”?

Vergelijk de prestaties van invoegen, verwijderen en directe toegang om het juiste lijsttype te kiezen. Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Java Academy te beginnen?

Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “LinkedList versus ArrayList: afwegingen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Java Academy?

Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Java Academy