Java PriorityQueue Klasse: Ein Leitfaden für Anfänger

Einführung

Hallo, zukünftige Java-Programmierer! Heute tauchen wir in die faszinierende Welt der PriorityQueue in Java ein. Keine Sorge, wenn du noch nie davon gehört hast – wir beginnen von Grund auf und arbeiten uns gemeinsam nach oben. Stelle dir eine PriorityQueue als eine spezielle Art von Warteschlange vor, in der immer der wichtigste Mensch (oder das wichtigste Item) als Erster dran kommt. Spannend, oder? Los geht's!

Java - PriorityQueue

Klassendeklaration

In Java ist die PriorityQueue-Klasse Teil des Java Collections Framework. Es ist wie eine VIP-Liste für deine Daten! So deklarierst du sie:

import java.util.PriorityQueue;

PriorityQueue<ElementType> pq = new PriorityQueue<>();

Ersetze ElementType durch den Typ der Daten, die du speichern möchtest, wie Integer, String oder sogar deine eigenen benutzerdefinierten Objekte (dazu kommen wir später).

Parameter

Beim Erstellen einer PriorityQueue kannst du einige optionale Parameter angeben:

Anfangskapazität: Wie viele Items sie initial halten kann.
Comparator: Ein spezielles Objekt, das die Reihenfolge der Elemente bestimmt.

Hier ist ein Beispiel:

PriorityQueue<Integer> pq = new PriorityQueue<>(10, Collections.reverseOrder());

Dies erstellt eine PriorityQueue, die initial 10 Ganze Zahlen halten kann, und diese werden von höchsten nach niedrigsten geordnet.

Klassenkonstruktoren

PriorityQueue kommt mit mehreren Konstruktoren. Stelle dir Konstruktoren als verschiedene Rezepte zum Erstellen deiner Warteschlange vor. Hier sind die Hauptkonstruktoren:

Konstruktor	Beschreibung
`PriorityQueue()`	Erstellt eine leere Warteschlange mit der Standardkapazität (11)
`PriorityQueue(int initialCapacity)`	Erstellt eine leere Warteschlange mit der angegebenen Anfangskapazität
`PriorityQueue(Comparator<? super E> comparator)`	Erstellt eine leere Warteschlange mit dem angegebenen Comparator
`PriorityQueue(Collection<? extends E> c)`	Erstellt eine Warteschlange, die die Elemente in der angegebenen Sammlung enthält

Sehen wir uns ein Beispiel an:

PriorityQueue<String> fruitQueue = new PriorityQueue<>();
PriorityQueue<Integer> numberQueue = new PriorityQueue<>(20);

In der ersten Zeile erstellen wir eine Warteschlange für Strings (vielleicht Fruchtnamen?). In der zweiten machen wir eine Warteschlange für Zahlen, die initial 20 Items halten kann.

Klassenmethoden

Nun schauen wir uns einige der coolen Dinge an, die du mit einer PriorityQueue machen kannst:

Methode	Beschreibung
`add(E e)`	Fügt ein Element zur Warteschlange hinzu
`offer(E e)`	Fügt ein Element zur Warteschlange hinzu (gibt false zurück, wenn voll)
`peek()`	Ruft das Kopfelement der Warteschlange ab, ohne es zu entfernen
`poll()`	Ruft das Kopfelement der Warteschlange ab und entfernt es
`remove(Object o)`	Entfernt eine einzelne Instanz des angegebenen Elements
`size()`	Gibt die Anzahl der Elemente in der Warteschlange zurück
`clear()`	Entfernt alle Elemente aus der Warteschlange

Sehen wir uns diese im Einsatz an:

PriorityQueue<String> animalQueue = new PriorityQueue<>();

animalQueue.add("Hund");
animalQueue.offer("Katze");
animalQueue.add("Elefant");

System.out.println("Peek: " + animalQueue.peek()); // Ausgabe: Peek: Katze
System.out.println("Poll: " + animalQueue.poll()); // Ausgabe: Poll: Katze
System.out.println("Size: " + animalQueue.size()); // Ausgabe: Size: 2

Notierst du, wie "Katze" zuerst kam? Das liegt daran, dass PriorityQueue Strings standardmäßig alphabetisch sortiert.

Vererbte Methoden

PriorityQueue vererbt auch Methoden von ihren Elternklassen. Es ist wie Bonusfunktionen zu erhalten! Einige nützliche davon sind:

contains(Object o): Überprüft, ob die Warteschlange das angegebene Element enthält
toArray(): Gibt ein Array zurück, das alle Elemente in der Warteschlange enthält
iterator(): Gibt einen Iterator über die Elemente in der Warteschlange zurück

Hier ist ein kurzes Beispiel:

PriorityQueue<Integer> numberQueue = new PriorityQueue<>();
numberQueue.add(5);
numberQueue.add(2);
numberQueue.add(8);

System.out.println("Contains 2? " + numberQueue.contains(2)); // Ausgabe: Contains 2? true

Object[] array = numberQueue.toArray();
System.out.println("First element: " + array[0]); // Ausgabe: First element: 2

Beispiel zum Hinzufügen eines Elements zu einer Priority Queue

Lassen Sie uns all das zusammen mit einem spaßigen Beispiel zusammenfassen. Stelle dir vor, wir organisieren eine Party, und wir möchten unsere Gäste in der Reihenfolge ihrer Ankunft begrüßen:

import java.util.PriorityQueue;

public class PartyGreeter {
public static void main(String[] args) {
PriorityQueue<Guest> guestQueue = new PriorityQueue<>();

guestQueue.add(new Guest("Alice", 18.30));
guestQueue.add(new Guest("Bob", 18.15));
guestQueue.add(new Guest("Charlie", 18.45));

while (!guestQueue.isEmpty()) {
Guest guest = guestQueue.poll();
System.out.println("Willkommen, " + guest.name + "! Du bist um " + guest.arrivalTime + " angekommen.");
}
}

static class Guest implements Comparable<Guest> {
String name;
double arrivalTime;

Guest(String name, double arrivalTime) {
this.name = name;
this.arrivalTime = arrivalTime;
}

@Override
public int compareTo(Guest other) {
return Double.compare(this.arrivalTime, other.arrivalTime);
}
}
}

Dieses Programm gibt folgendes aus:

Willkommen, Bob! Du bist um 18.15 angekommen.
Willkommen, Alice! Du bist um 18.3 angekommen.
Willkommen, Charlie! Du bist um 18.45 angekommen.

In diesem Beispiel haben wir eine benutzerdefinierte Guest-Klasse erstellt und Java gezeigt, wie man Gäste basierend auf ihrer Ankunftszeit vergleichen soll. Die PriorityQueue hat dann unsere Gäste automatisch für uns sortiert!

Und so ist es! Du hast gerade deine ersten Schritte in die Welt der PriorityQueues in Java gemacht. Denke daran, dass Übung macht den Meister, also mach' keine Angst, mit diesen Konzepten zu experimentieren. Wer weiß? Vielleicht nutzt du eine PriorityQueue, um die Gästeliste deiner nächsten Party zu organisieren!

Credits: Image by storyset