Java Academy · Les

PriorityQueue voor geordende verwerking

Gebruik PriorityQueue met natuurlijke ordening en aangepaste comparators voor scenario's met taakplanning.

Les 4 van 413 stappen

PriorityQueue voor geordende verwerking is een gratis Java Academy-les op CoddyKit. Dit is les 4 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.

Wat is een PriorityQueue?

Een PriorityQueue is standaard een min-heap: het element met de laagste natuurlijke volgorde staat altijd aan het hoofd. Elementen worden intern niet gesorteerd — alleen dat het minimum vooraan staat, wordt gegarandeerd.

import java.util.PriorityQueue;

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(30);
pq.offer(10);
pq.offer(20);

System.out.println(pq.poll()); // 10 (min)
System.out.println(pq.poll()); // 20
System.out.println(pq.poll()); // 30

Interne heapstructuur

PriorityQueue gebruikt een binaire min-heap die in een array is opgeslagen. De ouder op index i is altijd ≤ zijn kinderen op 2i+1 en 2i+2. Dit garandeert O(log n) voor offer/poll en O(1) voor peek.

Max-heap met omgekeerde comparator

Maak een max-heap (grootste element eerst) door Comparator.reverseOrder() mee te geven:

PriorityQueue<Integer> maxPQ = new PriorityQueue<>(Comparator.reverseOrder());
maxPQ.offer(10);
maxPQ.offer(50);
maxPQ.offer(30);

System.out.println(maxPQ.poll()); // 50 (max)
System.out.println(maxPQ.poll()); // 30

PriorityQueue met aangepaste objecten

Gebruik een comparator om aangepaste records of klassen te ordenen:

record Job(String name, int priority) {}

PriorityQueue<Job> queue = new PriorityQueue<>(
    Comparator.comparingInt(Job::priority) // ascending priority
);
queue.offer(new Job("Backup", 5));
queue.offer(new Job("Alert", 1));
queue.offer(new Job("Report", 3));

System.out.println(queue.poll().name()); // Alert (priority 1)

Peek versus poll

peek() retourneert het hoofdelement zonder het te verwijderen. poll() verwijdert het element en retourneert het. Beide retourneren null bij een lege wachtrij (in tegenstelling tot element()/remove(), die een uitzondering veroorzaken).

PriorityQueue<String> pq = new PriorityQueue<>();
pq.offer("banana");
pq.offer("apple");

System.out.println(pq.peek()); // apple (not removed)
System.out.println(pq.peek()); // apple (still there)
System.out.println(pq.poll()); // apple (removed)
System.out.println(pq.peek()); // banana

Voorbeeld van taakplanning

PriorityQueue is ideaal voor simulaties van CPU-planning waarin taken verschillende prioriteiten hebben:

record Task(String name, int priority) {}

PriorityQueue<Task> scheduler = new PriorityQueue<>(
    Comparator.comparingInt(Task::priority).reversed() // highest first
);
scheduler.offer(new Task("Low", 1));
scheduler.offer(new Task("Critical", 10));
scheduler.offer(new Task("Normal", 5));

while (!scheduler.isEmpty()) {
    System.out.println("Processing: " + scheduler.poll().name());
}
// Critical, Normal, Low

K kleinste elementen

PriorityQueue is een klassiek hulpmiddel om de K kleinste elementen te vinden zonder de array volledig te sorteren:

int[] nums = {7, 2, 5, 1, 9, 3, 8};
int k = 3;

PriorityQueue<Integer> pq = new PriorityQueue<>();
for (int n : nums) pq.offer(n);

for (int i = 0; i < k; i++) {
    System.out.print(pq.poll() + " ");
}
// 1 2 3

K grootste elementen met een max-heap

Je kunt ook tijdens het itereren een min-heap van grootte K bijhouden om de K grootste elementen te vinden:

int[] nums = {7, 2, 5, 1, 9, 3, 8};
int k = 3;

PriorityQueue<Integer> minHeap = new PriorityQueue<>();
for (int n : nums) {
    minHeap.offer(n);
    if (minHeap.size() > k) minHeap.poll(); // remove smallest
}
// minHeap now contains the 3 largest: [7, 8, 9]
System.out.println(minHeap); // order may vary

Patroon voor het algoritme van Dijkstra

Het kortste-padalgoritme van Dijkstra gebruikt een min-heap om steeds eerst het goedkoopste nog niet bezochte knooppunt uit te breiden:

record Entry(int node, int cost) {}

PriorityQueue<Entry> pq = new PriorityQueue<>(
    Comparator.comparingInt(Entry::cost)
);
pq.offer(new Entry(0, 0)); // start node, cost 0

while (!pq.isEmpty()) {
    Entry curr = pq.poll();
    System.out.println("Visit node " + curr.node() + " cost=" + curr.cost());
    // expand neighbors...
}

Iteratie heeft geen vaste volgorde

Itereren over een PriorityQueue retourneert elementen NIET in prioriteitsvolgorde — alleen poll() doet dat. Gebruik voor gesorteerde uitvoer herhaaldelijk poll in plaats van een for-each-lus.

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.addAll(List.of(5,3,1,4,2));

// WRONG for sorted output:
for (int n : pq) System.out.print(n+" "); // unordered!

// CORRECT:
while (!pq.isEmpty()) System.out.print(pq.poll()+" "); // 1 2 3 4 5

Samenvatting van de prestaties

Complexiteit van bewerkingen op PriorityQueue:

offer(e): O(log n)
poll(): O(log n)
peek(): O(1)
contains(e): O(n)
remove(e): O(n)

Niet thread-safe — gebruik PriorityBlockingQueue voor gelijktijdige toegang.

Korte controle

Wat wordt gegarandeerd over de volgorde van elementen wanneer je met een for-each-lus over een PriorityQueue itereert?

Beantwoord dit in de interactieve les

Samenvatting: PriorityQueue

Belangrijkste punten:

PriorityQueue is een min-heap: het kleinste element wordt als eerste opgehaald
Gebruik Comparator.reverseOrder() voor een max-heap
O(log n) voor offer/poll, O(1) voor peek
Klassieke toepassingen: het K-de grootste/kleinste element, Dijkstra en taakplanning
Een for-each-lus levert geen prioriteitsvolgorde op — gebruik poll()

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 “PriorityQueue voor geordende verwerking” gratis?

Ja — de volledige tekst van “PriorityQueue voor geordende verwerking” 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 “PriorityQueue voor geordende verwerking”?

Gebruik PriorityQueue met natuurlijke ordening en aangepaste comparators voor scenario's met taakplanning. 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 4 van 4.

Hoe lang duurt de les “PriorityQueue voor geordende verwerking”?

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