Java Academy · Les

Deque-bewerkingen: stack en queue

Gebruik LinkedList als Deque om stackgedrag (push/pop) en queuegedrag (offer/poll) te implementeren.

Les 2 van 413 stappen

Deque-bewerkingen: stack en queue is een gratis Java Academy-les op CoddyKit. Dit is les 2 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.

Deque: dubbelzijdige wachtrij

Met een Deque, een dubbelzijdige wachtrij, kun je aan beide uiteinden elementen invoegen en verwijderen. Java's Deque-interface wordt geïmplementeerd door LinkedList en ArrayDeque.

import java.util.Deque;
import java.util.ArrayDeque;

Deque<String> deque = new ArrayDeque<>();
deque.addFirst("A"); // front
deque.addLast("B");  // back
deque.addFirst("Z"); // new front

System.out.println(deque); // [Z, A, B]

ArrayDeque of LinkedList als Deque

ArrayDeque heeft over het algemeen de voorkeur boven LinkedList als Deque:

Geen extra knooppunt per element
Betere cachelokaliteit
Iets sneller voor stapel- en wachtrijbewerkingen

Kies alleen LinkedList wanneer je ook de List-interface nodig hebt.

Stapelbewerkingen met Deque

Gebruik push (addFirst) en pop (removeFirst) om een LIFO-stapel na te bootsen. Vermijd de verouderde Stack-klasse — deze is gesynchroniseerd en achterhaald.

Deque<Integer> stack = new ArrayDeque<>();
stack.push(1);
stack.push(2);
stack.push(3);

System.out.println(stack.pop());  // 3
System.out.println(stack.peek()); // 2 (no removal)
System.out.println(stack.pop());  // 2

Wachtrijbewerkingen met Deque

Gebruik offer (addLast) en poll (removeFirst) om een FIFO-wachtrij na te bootsen. offer geeft false terug bij een fout; add gooit een uitzondering.

Deque<String> queue = new ArrayDeque<>();
queue.offer("task1");
queue.offer("task2");
queue.offer("task3");

System.out.println(queue.poll());  // task1
System.out.println(queue.poll());  // task2
System.out.println(queue.size());  // 1

Referentietabel voor Deque-methoden

Deque biedt twee methodenfamilies — één die uitzonderingen gooit en één die speciale waarden teruggeeft:

addFirst/addLast tegenover offerFirst/offerLast
removeFirst/removeLast tegenover pollFirst/pollLast
getFirst/getLast tegenover peekFirst/peekLast

Geef de voorkeur aan de offer/poll/peek-familie om uitzonderingen bij lege deques te voorkomen.

Praktijkvoorbeeld: ongedaan maken en opnieuw uitvoeren met twee stapels

Een klassieke toepassing van Deque: de geschiedenis van ongedaan maken is een stapel. Opnieuw uitvoeren is een andere stapel.

Deque<String> undo = new ArrayDeque<>();
Deque<String> redo = new ArrayDeque<>();

undo.push("type 'Hello'");
undo.push("type ' World'");

String action = undo.pop();
System.out.println("Undone: " + action); // type ' World'
redo.push(action);

System.out.println("Redo top: " + redo.peek()); // type ' World'

Een palindroom controleren met Deque

Met deques kun je palindromen elegant controleren — vergelijk tekens tegelijkertijd vanaf beide uiteinden.

Deque<Character> deque = new ArrayDeque<>();
for (char c : "racecar".toCharArray()) deque.add(c);

boolean isPalindrome = true;
while (deque.size() > 1) {
    if (!deque.pollFirst().equals(deque.pollLast())) {
        isPalindrome = false;
        break;
    }
}
System.out.println(isPalindrome); // true

BFS met een wachtrij

Breedte-eerst zoeken gebruikt een wachtrij. ArrayDeque is de standaardkeuze voor BFS bij competitief programmeren en het doorlopen van grafen.

import java.util.*;

// BFS on a simple adjacency list
Map<Integer,List<Integer>> graph = Map.of(
    1, List.of(2,3),
    2, List.of(4),
    3, List.of(4),
    4, List.of()
);
Deque<Integer> queue = new ArrayDeque<>();
Set<Integer> visited = new HashSet<>();
queue.offer(1);
while (!queue.isEmpty()) {
    int node = queue.poll();
    if (visited.add(node)) {
        System.out.print(node + " ");
        queue.addAll(graph.get(node));
    }
}

DFS met een stapel

Diepte-eerst zoeken gebruikt een stapel. Geef opnieuw de voorkeur aan ArrayDeque boven de verouderde klasse Stack.

Deque<Integer> stack = new ArrayDeque<>();
Set<Integer> visited = new HashSet<>();
stack.push(1);
while (!stack.isEmpty()) {
    int node = stack.pop();
    if (visited.add(node)) {
        System.out.print(node + " ");
        // push neighbors (will be processed in reverse order)
        List<Integer> neighbors = List.of(2, 3); // simplified
        for (int n : neighbors) if (!visited.contains(n)) stack.push(n);
    }
}

Begrensde Deque met groottecontrole

ArrayDeque groeit dynamisch, maar je kunt handmatig een capaciteit afdwingen om een begrensde buffer na te bootsen:

Deque<Integer> buffer = new ArrayDeque<>();
int MAX = 3;

for (int i = 1; i <= 5; i++) {
    if (buffer.size() >= MAX) {
        buffer.pollFirst(); // drop oldest
    }
    buffer.offerLast(i);
}
System.out.println(buffer); // [3, 4, 5]

Opmerkingen over prestaties

ArrayDeque gebruikt een circulaire array die verdubbelt wanneer deze vol is. De geamortiseerde kosten van alle bewerkingen zijn O(1). De prestaties zijn in de meeste benchmarks beter dan die van LinkedList dankzij efficiënter cachegebruik. Synchroniseer nooit handmatig — gebruik ConcurrentLinkedDeque of een blokkerende wachtrij voor gelijktijdige verwerking.

Korte controle

Welke klasse heeft de voorkeur boven de verouderde Stack voor LIFO-bewerkingen?

Beantwoord dit in de interactieve les

Samenvatting: Deque-bewerkingen

Belangrijkste punten:

Deque maakt invoegen en verwijderen aan beide uiteinden mogelijk in O(1)
ArrayDeque heeft de voorkeur boven LinkedList voor puur gebruik als stapel of wachtrij
push/pop → LIFO-stapel; offer/poll → FIFO-wachtrij
Klassieke toepassingen: ongedaan maken/opnieuw uitvoeren, BFS/DFS, schuivend venster en palindroomcontrole
Vermijd de verouderde klassen Stack en Queue

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 “Deque-bewerkingen: stack en queue” gratis?

Ja — de volledige tekst van “Deque-bewerkingen: stack en queue” 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 “Deque-bewerkingen: stack en queue”?

Gebruik LinkedList als Deque om stackgedrag (push/pop) en queuegedrag (offer/poll) te implementeren. 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 2 van 4.

Hoe lang duurt de les “Deque-bewerkingen: stack en queue”?

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