Die Queue-Schnittstelle ist in vorhanden java.util Paket und erweitert die Sammlungsschnittstelle wird verwendet, um die zu verarbeitenden Elemente in der FIFO-Reihenfolge (First In First Out) zu speichern. Es handelt sich um eine geordnete Liste von Objekten, deren Verwendung auf das Einfügen von Elementen am Ende der Liste und das Löschen von Elementen am Anfang der Liste beschränkt ist (d. h.), sie folgt dem FIFO oder das First-In-First-Out-Prinzip.
Da es sich um eine Schnittstelle handelt, benötigt die Warteschlange eine konkrete Klasse für die Deklaration, und die häufigsten Klassen sind die Prioritätswarteschlange Und LinkedList in Java. Beachten Sie, dass keine dieser Implementierungen threadsicher ist. PriorityBlockingQueue ist eine alternative Implementierung, wenn die Thread-sichere Implementierung benötigt wird.
Erklärung: Die Queue-Schnittstelle ist wie folgt deklariert:
public interface Queue extends Collection>
Queue-Objekte erstellen: Seit Warteschlange ist ein Schnittstelle Es können keine Objekte vom Typ Warteschlange erstellt werden. Wir benötigen immer eine Klasse, die diese Liste erweitert, um ein Objekt zu erstellen. Und auch nach der Einführung von Generika In Java 1.5 ist es möglich, den Objekttyp einzuschränken, der in der Warteschlange gespeichert werden kann. Diese typsichere Warteschlange kann wie folgt definiert werden:
// Obj is the type of the object to be stored in Queue Queue queue = new PriorityQueue ();>
In Java ist die Queue-Schnittstelle ein Untertyp der Collection-Schnittstelle und stellt eine Sammlung von Elementen in einer bestimmten Reihenfolge dar. Es folgt dem First-In-First-Out-Prinzip (FIFO), was bedeutet, dass die Elemente in der Reihenfolge abgerufen werden, in der sie der Warteschlange hinzugefügt wurden.
Die Queue-Schnittstelle bietet verschiedene Methoden zum Hinzufügen, Entfernen und Überprüfen von Elementen in der Warteschlange. Hier sind einige der am häufigsten verwendeten Methoden:
add(element): Fügt ein Element am Ende der Warteschlange hinzu. Wenn die Warteschlange voll ist, wird eine Ausnahme ausgelöst.
offer(element): Fügt ein Element am Ende der Warteschlange hinzu. Wenn die Warteschlange voll ist, wird false zurückgegeben.
remove(): Entfernt das Element am Anfang der Warteschlange und gibt es zurück. Wenn die Warteschlange leer ist, wird eine Ausnahme ausgelöst.
poll(): Entfernt das Element am Anfang der Warteschlange und gibt es zurück. Wenn die Warteschlange leer ist, wird null zurückgegeben.
element(): Gibt das Element am Anfang der Warteschlange zurück, ohne es zu entfernen. Wenn die Warteschlange leer ist, wird eine Ausnahme ausgelöst.
peek(): Gibt das Element am Anfang der Warteschlange zurück, ohne es zu entfernen. Wenn die Warteschlange leer ist, wird null zurückgegeben.
Die Queue-Schnittstelle wird von mehreren Klassen in Java implementiert, darunter LinkedList, ArrayDeque und PriorityQueue. Jede dieser Klassen bietet unterschiedliche Implementierungen der Warteschlangenschnittstelle mit unterschiedlichen Leistungsmerkmalen und Funktionen.
Insgesamt ist die Queue-Schnittstelle ein nützliches Tool zum Verwalten von Elementsammlungen in einer bestimmten Reihenfolge und wird in vielen verschiedenen Anwendungen und Branchen häufig verwendet.
Beispiel:
Java
import> java.util.LinkedList;> import> java.util.Queue;> public> class> QueueExample {> >public> static> void> main(String[] args) {> >Queue queue =>new> LinkedList();> >// add elements to the queue> >queue.add(>'apple'>);> >queue.add(>'banana'>);> >queue.add(>'cherry'>);> >// print the queue> >System.out.println(>'Queue: '> + queue);> >// remove the element at the front of the queue> >String front = queue.remove();> >System.out.println(>'Removed element: '> + front);> >// print the updated queue> >System.out.println(>'Queue after removal: '> + queue);> >// add another element to the queue> >queue.add(>'date'>);> >// peek at the element at the front of the queue> >String peeked = queue.peek();> >System.out.println(>'Peeked element: '> + peeked);> >// print the updated queue> >System.out.println(>'Queue after peek: '> + queue);> >}> }> |
>
>Ausgabe
Queue: [apple, banana, cherry] Removed element: apple Queue after removal: [banana, cherry] Peeked element: banana Queue after peek: [banana, cherry, date]>
Beispiel: Warteschlange
Java
Websites wie bedpage
// Java program to demonstrate a Queue> import> java.util.LinkedList;> import> java.util.Queue;> public> class> QueueExample {> >public> static> void> main(String[] args)> >{> >Queue q> >=>new> LinkedList();> >// Adds elements {0, 1, 2, 3, 4} to> >// the queue> >for> (>int> i =>0>; i <>5>; i++)> >q.add(i);> >// Display contents of the queue.> >System.out.println(>'Elements of queue '> >+ q);> >// To remove the head of queue.> >int> removedele = q.remove();> >System.out.println(>'removed element-'> >+ removedele);> >System.out.println(q);> >// To view the head of queue> >int> head = q.peek();> >System.out.println(>'head of queue-'> >+ head);> >// Rest all methods of collection> >// interface like size and contains> >// can be used with this> >// implementation.> >int> size = q.size();> >System.out.println(>'Size of queue-'> >+ size);> >}> }> |
>
>Ausgabe
Elements of queue [0, 1, 2, 3, 4] removed element-0 [1, 2, 3, 4] head of queue-1 Size of queue-4>
Operationen an der Warteschlangenschnittstelle
Sehen wir uns an, wie Sie mithilfe von einige häufig verwendete Vorgänge in der Warteschlange ausführen Priority Queue-Klasse .
1. Elemente hinzufügen: Um ein Element zu einer Warteschlange hinzuzufügen, können wir Folgendes verwenden add()-Methode . Die Einfügungsreihenfolge wird nicht in der PriorityQueue beibehalten. Die Elemente werden nach der standardmäßig aufsteigenden Prioritätsreihenfolge gespeichert.
Beispiel
Java
// Java program to add elements> // to a Queue> import> java.util.*;> public> class> GFG {> >public> static> void> main(String args[])> >{> >Queue pq =>new> PriorityQueue();> >pq.add(>'Geeks'>);> >pq.add(>'For'>);> >pq.add(>'Geeks'>);> >System.out.println(pq);> >}> }> |
>
>Ausgabe
[For, Geeks, Geeks]>
2. Elemente entfernen: Um ein Element aus einer Warteschlange zu entfernen, können wir verwenden Methode „remove()“. Wenn mehrere solcher Objekte vorhanden sind, wird das erste Vorkommen des Objekts entfernt. Darüber hinaus wird die Methode poll() auch verwendet, um den Kopf zu entfernen und zurückzugeben.
Beispiel
Java
// Java program to remove elements> // from a Queue> import> java.util.*;> public> class> GFG {> >public> static> void> main(String args[])> >{> >Queue pq =>new> PriorityQueue();> >pq.add(>'Geeks'>);> >pq.add(>'For'>);> >pq.add(>'Geeks'>);> >System.out.println(>'Initial Queue '> + pq);> >pq.remove(>'Geeks'>);> >System.out.println(>'After Remove '> + pq);> >System.out.println(>'Poll Method '> + pq.poll());> >System.out.println(>'Final Queue '> + pq);> >}> }> |
>
>Ausgabe
Initial Queue [For, Geeks, Geeks] After Remove [For, Geeks] Poll Method For Final Queue [Geeks]>
3. Iterieren der Warteschlange: Es gibt mehrere Möglichkeiten, die Warteschlange zu durchlaufen. Die bekannteste Methode ist die Konvertierung der Warteschlange in ein Array und das Durchlaufen mithilfe der for-Schleife. Die Warteschlange verfügt jedoch auch über einen integrierten Iterator, der zum Durchlaufen der Warteschlange verwendet werden kann.
Beispiel
Java
// Java program to iterate elements> // to a Queue> import> java.util.*;> public> class> GFG {> >public> static> void> main(String args[])> >{> >Queue pq =>new> PriorityQueue();> >pq.add(>'Geeks'>);> >pq.add(>'For'>);> >pq.add(>'Geeks'>);> >Iterator iterator = pq.iterator();> >while> (iterator.hasNext()) {> >System.out.print(iterator.next() +>' '>);> >}> >}> }> |
>
>Ausgabe
For Geeks Geeks>
Merkmale einer Warteschlange: Im Folgenden sind die Merkmale der Warteschlange aufgeführt:
- Die Warteschlange wird verwendet, um Elemente am Ende der Warteschlange einzufügen und am Anfang der Warteschlange zu entfernen. Es folgt dem FIFO-Konzept.
- Die Java-Warteschlange unterstützt alle Methoden der Collection-Schnittstelle, einschließlich Einfügen, Löschen usw.
- LinkedList , ArrayBlockingQueue und Prioritätswarteschlange sind die am häufigsten verwendeten Implementierungen.
- Wenn eine Nulloperation für BlockingQueues ausgeführt wird, wird eine NullPointerException ausgelöst.
- Die im Paket java.util verfügbaren Warteschlangen sind unbegrenzte Warteschlangen.
- Die Warteschlangen, die im Paket java.util.concurrent verfügbar sind, sind die begrenzten Warteschlangen.
- Alle Warteschlangen mit Ausnahme der Deques unterstützen das Einfügen und Entfernen am Ende bzw. Kopf der Warteschlange. Die Deques unterstützen das Einsetzen und Entfernen des Elements an beiden Enden.
Klassen, die die Queue-Schnittstelle implementieren:
1. Prioritätswarteschlange: Die im Sammlungsframework implementierte PriorityQueue-Klasse bietet uns eine Möglichkeit, die Objekte basierend auf der Priorität zu verarbeiten. Es ist bekannt, dass eine Warteschlange dem First-In-First-Out-Algorithmus folgt, aber manchmal müssen die Elemente der Warteschlange entsprechend ihrer Priorität verarbeitet werden. Dann kommt die PriorityQueue ins Spiel. Sehen wir uns an, wie man mit dieser Klasse ein Warteschlangenobjekt erstellt.
Beispiel
Java
// Java program to demonstrate the> // creation of queue object using the> // PriorityQueue class> import> java.util.*;> class> GfG {> >public> static> void> main(String args[])> >{> >// Creating empty priority queue> >Queue pQueue> >=>new> PriorityQueue();> >// Adding items to the pQueue> >// using add()> >pQueue.add(>10>);> >pQueue.add(>20>);> >pQueue.add(>15>);> >// Printing the top element of> >// the PriorityQueue> >System.out.println(pQueue.peek());> >// Printing the top element and removing it> >// from the PriorityQueue container> >System.out.println(pQueue.poll());> >// Printing the top element again> >System.out.println(pQueue.peek());> >}> }> |
>
>Ausgabe
10 10 15>
2. Verlinkte Liste: LinkedList ist eine Klasse, die im Sammlungsframework implementiert ist, das von Natur aus implementiert Beispiel
Java
Zufallszahlen-C-Code
// Java program to demonstrate the> // creation of queue object using the> // LinkedList class> import> java.util.*;> class> GfG {> >public> static> void> main(String args[])> >{> >// Creating empty LinkedList> >Queue ll> >=>new> LinkedList();> >// Adding items to the ll> >// using add()> >ll.add(>10>);> >ll.add(>20>);> >ll.add(>15>);> >// Printing the top element of> >// the LinkedList> >System.out.println(ll.peek());> >// Printing the top element and removing it> >// from the LinkedList container> >System.out.println(ll.poll());> >// Printing the top element again> >System.out.println(ll.peek());> >}> }> |
>
>Ausgabe
10 10 20>
3. PriorityBlockingQueue: Es ist zu beachten, dass beide Implementierungen, PriorityQueue und LinkedList, nicht threadsicher sind. PriorityBlockingQueue ist eine alternative Implementierung, wenn eine threadsichere Implementierung erforderlich ist. PriorityBlockingQueue ist eine unbegrenzte Blockierungswarteschlange, die dieselben Ordnungsregeln wie die Klasse verwendet Prioritätswarteschlange und liefert blockierende Abrufvorgänge.
Da es unbegrenzt ist, kann das Hinzufügen von Elementen manchmal aufgrund einer Ressourcenerschöpfung fehlschlagen, was dazu führt Außerhalb des Speicherfehler . Sehen wir uns an, wie man mit dieser Klasse ein Warteschlangenobjekt erstellt.
Beispiel
Java
// Java program to demonstrate the> // creation of queue object using the> // PriorityBlockingQueue class> import> java.util.concurrent.PriorityBlockingQueue;> import> java.util.*;> class> GfG {> >public> static> void> main(String args[])> >{> >// Creating empty priority> >// blocking queue> >Queue pbq> >=>new> PriorityBlockingQueue();> >// Adding items to the pbq> >// using add()> >pbq.add(>10>);> >pbq.add(>20>);> >pbq.add(>15>);> >// Printing the top element of> >// the PriorityBlockingQueue> >System.out.println(pbq.peek());> >// Printing the top element and> >// removing it from the> >// PriorityBlockingQueue> >System.out.println(pbq.poll());> >// Printing the top element again> >System.out.println(pbq.peek());> >}> }> |
>
>Ausgabe
10 10 15>
Methoden der Warteschlangenschnittstelle
Die Warteschlangenschnittstelle erbt alle in der Warteschlangenschnittstelle Sammlungsschnittstelle bei der Implementierung der folgenden Methoden:
| Methode | Beschreibung |
|---|---|
| add(int index, element) | Mit dieser Methode wird ein Element an einem bestimmten Index in der Warteschlange hinzugefügt. Wenn ein einzelner Parameter übergeben wird, wird das Element einfach am Ende der Warteschlange hinzugefügt. |
| addAll(int index, Collection-Sammlung) | Mit dieser Methode werden alle Elemente in der angegebenen Sammlung zur Warteschlange hinzugefügt. Wenn ein einzelner Parameter übergeben wird, werden alle Elemente der angegebenen Sammlung am Ende der Warteschlange hinzugefügt. |
| Größe() | Mit dieser Methode wird die Größe der Warteschlange zurückgegeben. |
| klar() | Mit dieser Methode werden alle Elemente in der Warteschlange entfernt. Die Referenz der erstellten Warteschlange bleibt jedoch weiterhin gespeichert. |
| entfernen() | Mit dieser Methode wird das Element vom Anfang der Warteschlange entfernt. |
| entfernen(int index) | Diese Methode entfernt ein Element aus dem angegebenen Index. Es verschiebt nachfolgende Elemente (falls vorhanden) nach links und verringert ihre Indizes um 1. |
| (Element) entfernen | Diese Methode wird verwendet, um das erste Vorkommen des angegebenen Elements in der Warteschlange zu entfernen und zurückzugeben. |
| get(int index) | Diese Methode gibt Elemente am angegebenen Index zurück. |
| set(int index, element) | Diese Methode ersetzt Elemente an einem bestimmten Index durch das neue Element. Diese Funktion gibt das Element zurück, das gerade durch ein neues Element ersetzt wurde. |
| indexOf(element) | Diese Methode gibt das erste Vorkommen des angegebenen Elements oder zurück -1 wenn das Element nicht in der Warteschlange vorhanden ist. |
| lastIndexOf(element) | Diese Methode gibt das letzte Vorkommen des angegebenen Elements oder zurück -1 wenn das Element nicht in der Warteschlange vorhanden ist. |
| gleicht(Element) | Diese Methode wird verwendet, um die Gleichheit des angegebenen Elements mit den Elementen der Warteschlange zu vergleichen. |
| Hash-Code() | Diese Methode wird verwendet, um den Hashcode-Wert der angegebenen Warteschlange zurückzugeben. |
| ist leer() | Mit dieser Methode wird überprüft, ob die Warteschlange leer ist oder nicht. Es gibt „true“ zurück, wenn die Warteschlange leer ist, andernfalls „false“. |
| enthält(Element) | Mit dieser Methode wird überprüft, ob die Warteschlange das angegebene Element enthält oder nicht. Es gibt true zurück, wenn die Warteschlange das Element enthält. |
| enthältAlle(Sammlung Sammlung) | Mit dieser Methode wird überprüft, ob die Warteschlange die gesamte Elementsammlung enthält. |
| sort(Komparator comp) | Diese Methode wird verwendet, um die Elemente der Warteschlange anhand der angegebenen Werte zu sortieren Komparator . |
| boolesches Add(Objekt) | Mit dieser Methode wird das angegebene Element in eine Warteschlange eingefügt und bei Erfolg „true“ zurückgegeben. |
| boolesches Angebot (Objekt) | Mit dieser Methode wird das angegebene Element in die Warteschlange eingefügt. |
| Objektumfrage() | Diese Methode wird verwendet, um den Kopf der Warteschlange abzurufen und zu entfernen, oder gibt null zurück, wenn die Warteschlange leer ist. |
| Objektelement() | Diese Methode wird verwendet, um den Kopf der Warteschlange abzurufen, aber nicht zu entfernen. |
| Objekt-Peek() | Diese Methode wird verwendet, um den Kopf dieser Warteschlange abzurufen, aber nicht zu entfernen, oder gibt null zurück, wenn diese Warteschlange leer ist. |
Vorteile der Verwendung der Queue-Schnittstelle in Java:
Auftragserhaltung : Die Queue-Schnittstelle bietet eine Möglichkeit, Elemente in einer bestimmten Reihenfolge nach dem First-In-First-Out-Prinzip (FIFO) zu speichern und abzurufen.
Flexibilität : Die Queue-Schnittstelle ist ein Untertyp der Collection-Schnittstelle, was bedeutet, dass sie je nach den Anforderungen der Anwendung mit vielen verschiedenen Datenstrukturen und Algorithmen verwendet werden kann.
Faden – Sicherheit : Einige Implementierungen der Queue-Schnittstelle, wie z. B. die Klasse java.util.concurrent.ConcurrentLinkedQueue, sind threadsicher, was bedeutet, dass mehrere Threads gleichzeitig auf sie zugreifen können, ohne dass es zu Konflikten kommt.
Leistung : Die Queue-Schnittstelle bietet effiziente Implementierungen zum Hinzufügen, Entfernen und Überprüfen von Elementen und ist damit ein nützliches Tool für die Verwaltung von Elementsammlungen in leistungskritischen Anwendungen.
Nachteile der Verwendung der Queue-Schnittstelle in Java:
Eingeschränkte Funktionalität: Die Queue-Schnittstelle ist speziell für die Verwaltung von Elementsammlungen in einer bestimmten Reihenfolge konzipiert, was bedeutet, dass sie für komplexere Datenstrukturen oder Algorithmen möglicherweise nicht geeignet ist.
Größenbeschränkungen: Einige Implementierungen der Queue-Schnittstelle, beispielsweise die ArrayDeque-Klasse, haben eine feste Größe, was bedeutet, dass sie nicht über eine bestimmte Anzahl von Elementen hinaus wachsen können.
Speichernutzung: Abhängig von der Implementierung benötigt die Queue-Schnittstelle möglicherweise mehr Speicher als andere Datenstrukturen, insbesondere wenn zusätzliche Informationen über die Reihenfolge der Elemente gespeichert werden müssen.
Komplexität : Die Queue-Schnittstelle kann für unerfahrene Programmierer schwierig zu verwenden und zu verstehen sein, insbesondere wenn sie mit den Prinzipien von Datenstrukturen und Algorithmen nicht vertraut sind.