Java PriorityQueue
Java-Prioritätswarteschlange
In diesem Tutorial lernen wir anhand von Beispielen die PriorityQueue-Klasse des Java Collections Framework kennen.
Der PriorityQueue Klasse bietet die Funktionalität der Heap-Datenstruktur.
Es implementiert die Queue-Schnittstelle.
Im Gegensatz zu normalen Warteschlangen werden Prioritäts-Warteschlangenelemente in sortierter Reihenfolge abgerufen.
Angenommen, wir möchten Elemente in aufsteigender Reihenfolge abrufen. In diesem Fall ist der Kopf der Prioritätswarteschlange das kleinste Element. Sobald dieses Element abgerufen wurde, ist das nächstkleinere Element der Kopf der Warteschlange.
Es ist wichtig zu beachten, dass die Elemente einer Prioritätswarteschlange möglicherweise nicht sortiert sind. Elemente werden jedoch immer in sortierter Reihenfolge abgerufen.
Prioritätswarteschlange erstellen
Um eine Prioritätswarteschlange zu erstellen, müssen wir den java.util.PriorityQueue importieren Paket. Sobald wir das Paket importiert haben, können wir wie folgt eine Prioritätswarteschlange in Java erstellen.
PriorityQueue<Integer> numbers = new PriorityQueue<>();
Hier haben wir eine Prioritätswarteschlange ohne Argumente erstellt. In diesem Fall ist der Kopf der Prioritätswarteschlange das kleinste Element der Warteschlange. Und Elemente werden in aufsteigender Reihenfolge aus der Warteschlange entfernt.
Allerdings können wir die Reihenfolge der Elemente mit Hilfe des Comparator anpassen Schnittstelle. Wir werden später in diesem Tutorial mehr darüber erfahren.
PriorityQueue-Methoden
Die PriorityQueue Klasse stellt die Implementierung aller Methoden bereit, die in Queue vorhanden sind Schnittstelle.
Elemente in PriorityQueue einfügen
add()- Fügt das angegebene Element in die Warteschlange ein. Wenn die Warteschlange voll ist, wird eine Ausnahme ausgelöst.offer()- Fügt das angegebene Element in die Warteschlange ein. Wenn die Warteschlange voll ist, wirdfalsezurückgegeben .
Zum Beispiel
import java.util.PriorityQueue;
class Main {
public static void main(String[] args) {
// Creating a priority queue
PriorityQueue<Integer> numbers = new PriorityQueue<>();
// Using the add() method
numbers.add(4);
numbers.add(2);
System.out.println("PriorityQueue: " + numbers);
// Using the offer() method
numbers.offer(1);
System.out.println("Updated PriorityQueue: " + numbers);
}
}
Ausgabe
PriorityQueue: [2, 4] Updated PriorityQueue: [1, 4, 2]
Hier haben wir eine Prioritätswarteschlange namens numbers erstellt . Wir haben 4 und 2 in die Warteschlange eingefügt.
Obwohl 4 vor 2 eingefügt wird, ist der Kopf der Warteschlange 2. Dies liegt daran, dass der Kopf der Prioritätswarteschlange das kleinste Element der Warteschlange ist.
Wir haben dann 1 in die Warteschlange eingefügt. Die Warteschlange wird nun neu angeordnet, um das kleinste Element 1 am Anfang der Warteschlange zu speichern.
Zugriff auf PriorityQueue-Elemente
Um auf Elemente aus einer Prioritätswarteschlange zuzugreifen, können wir den peek() verwenden Methode. Diese Methode gibt den Kopf der Warteschlange zurück. Zum Beispiel
import java.util.PriorityQueue;
class Main {
public static void main(String[] args) {
// Creating a priority queue
PriorityQueue<Integer> numbers = new PriorityQueue<>();
numbers.add(4);
numbers.add(2);
numbers.add(1);
System.out.println("PriorityQueue: " + numbers);
// Using the peek() method
int number = numbers.peek();
System.out.println("Accessed Element: " + number);
}
}
Ausgabe
PriorityQueue: [1, 4, 2] Accessed Element: 1
PriorityQueue-Elemente entfernen
remove()- entfernt das angegebene Element aus der Warteschlangepoll()- gibt den Kopf der Warteschlange zurück und entfernt ihn
Zum Beispiel
import java.util.PriorityQueue;
class Main {
public static void main(String[] args) {
// Creating a priority queue
PriorityQueue<Integer> numbers = new PriorityQueue<>();
numbers.add(4);
numbers.add(2);
numbers.add(1);
System.out.println("PriorityQueue: " + numbers);
// Using the remove() method
boolean result = numbers.remove(2);
System.out.println("Is the element 2 removed? " + result);
// Using the poll() method
int number = numbers.poll();
System.out.println("Removed Element Using poll(): " + number);
}
}
Ausgabe
PriorityQueue: [1, 4, 2] Is the element 2 removed? true Removed Element Using poll(): 1
Iteration über eine PriorityQueue
Um die Elemente einer Prioritätswarteschlange zu durchlaufen, können wir den iterator() verwenden Methode. Um diese Methode zu verwenden, müssen wir den java.util.Iterator importieren Paket. Zum Beispiel
import java.util.PriorityQueue;
import java.util.Iterator;
class Main {
public static void main(String[] args) {
// Creating a priority queue
PriorityQueue<Integer> numbers = new PriorityQueue<>();
numbers.add(4);
numbers.add(2);
numbers.add(1);
System.out.print("PriorityQueue using iterator(): ");
//Using the iterator() method
Iterator<Integer> iterate = numbers.iterator();
while(iterate.hasNext()) {
System.out.print(iterate.next());
System.out.print(", ");
}
}
}
Ausgabe
PriorityQueue using iterator(): 1, 4, 2,
Andere PriorityQueue-Methoden
| Methoden | Beschreibungen |
|---|---|
contains(element) | Durchsucht die Prioritätswarteschlange nach dem angegebenen Element. Wenn das Element gefunden wird, gibt es true zurück , wenn nicht, wird false zurückgegeben . |
size() | Gibt die Länge der Prioritätswarteschlange zurück. |
toArray() | Konvertiert eine Prioritätswarteschlange in ein Array und gibt es zurück. |
PriorityQueue Comparator
In allen obigen Beispielen werden Prioritätswarteschlangenelemente in der natürlichen Reihenfolge (aufsteigende Reihenfolge) abgerufen. Wir können diese Reihenfolge jedoch anpassen.
Dazu müssen wir unsere eigene Komparatorklasse erstellen, die den Comparator implementiert Schnittstelle. Zum Beispiel
import java.util.PriorityQueue;
import java.util.Comparator;
class Main {
public static void main(String[] args) {
// Creating a priority queue
PriorityQueue<Integer> numbers = new PriorityQueue<>(new CustomComparator());
numbers.add(4);
numbers.add(2);
numbers.add(1);
numbers.add(3);
System.out.print("PriorityQueue: " + numbers);
}
}
class CustomComparator implements Comparator<Integer> {
@Override
public int compare(Integer number1, Integer number2) {
int value = number1.compareTo(number2);
// elements are sorted in reverse order
if (value > 0) {
return -1;
}
else if (value < 0) {
return 1;
}
else {
return 0;
}
}
}
Ausgabe
PriorityQueue: [4, 3, 1, 2]
Im obigen Beispiel haben wir eine Prioritätswarteschlange erstellt, die CustomComparator übergibt Klasse als Argument.
Der CustomComparator Klasse implementiert den Comparator Schnittstelle.
Wir überschreiben dann den compare() Methode. Die Methode bewirkt nun, dass der Kopf des Elements die größte Zahl ist.
Um mehr über den Komparator zu erfahren, besuchen Sie Java Comparator.
Java