java queue queue methods
In diesem Tutorial werden wir diskutieren, was eine Warteschlange in Java ist, wie man sie verwendet, Java-Warteschlangenbeispiel, Java-Warteschlangenmethoden und Implementierung der Warteschlangenschnittstelle:
Eine Warteschlange ist eine lineare Datenstruktur oder eine Sammlung in Java, in der Elemente in einer FIFO-Reihenfolge (First In, First Out) gespeichert werden.
Die Warteschlangensammlung hat zwei Enden, d. H. Vorne und hinten. Die Elemente werden hinten hinzugefügt und von vorne entfernt.
=> Besuchen Sie hier, um die Java-Schulungsreihe für alle zu sehen.
Was du lernen wirst:
Was ist eine Java-Warteschlange?
Eine Warteschlangendatenstruktur wird wie folgt dargestellt:
Wie im obigen Diagramm gezeigt, ist eine Warteschlange eine Struktur mit zwei Punkten, d. H. Start (vorne) und Ende (hinten). Elemente werden am hinteren Ende in die Warteschlange eingefügt und vorne aus der Warteschlange entfernt.
In Java ist Queue eine Schnittstelle, die Teil des Pakets java.util ist. Die Warteschlangenschnittstelle erweitert die Java Collection-Schnittstelle.
Die allgemeine Definition der Warteschlangenschnittstelle lautet:
public interface Queue extends Collection
Da die Warteschlange eine Schnittstelle ist, kann sie nicht instanziiert werden. Wir benötigen einige konkrete Klassen, um die Funktionalität der Warteschlangenschnittstelle zu implementieren. Zwei Klassen implementieren die Warteschlangenschnittstelle, d. H. LinkedList und PriorityQueue.
Im Folgenden sind einige der Hauptmerkmale der Warteschlangendatenstruktur aufgeführt:
- Die Warteschlange folgt der FIFO-Reihenfolge (First In, First Out). Dies bedeutet, dass das Element am Ende in die Warteschlange eingefügt und am Anfang aus der Warteschlange entfernt wird.
- Die Java-Warteschlangenschnittstelle bietet alle Methoden der Sammlungsschnittstelle wie Einfügen, Löschen usw.
- LinkedList und PriorityQueue sind die Klassen, die die Warteschlangenschnittstelle implementieren. ArrayBlockingQueue ist eine weitere Klasse, die die Queue-Schnittstelle implementiert.
- Die Warteschlangen, die Teil des Pakets java.util sind, können als unbegrenzte Warteschlangen klassifiziert werden, während die in java.util vorhandenen gleichzeitigen Pakete begrenzte Warteschlangen sind.
- Die Deque ist eine Warteschlange, die das Einfügen und Löschen an beiden Enden unterstützt.
- Die Deque ist fadensicher.
- BlockingQueues sind threadsicher und werden zur Implementierung von Producer-Consumer-Problemen verwendet.
- BlockingQueues erlauben keine Nullelemente. Eine NullPointerException wird ausgelöst, wenn eine Operation in Bezug auf Nullwerte versucht wird.
Wie verwende ich eine Warteschlange in Java?
Um eine Warteschlange in Java zu verwenden, müssen wir zuerst die Warteschlangenschnittstelle wie folgt importieren:
import java.util.queue;
Oder
import java.util.*;
Sobald dies importiert ist, können wir eine Warteschlange wie unten gezeigt erstellen:
Queue str_queue = new LinkedList ();
Da Queue eine Schnittstelle ist, verwenden wir eine LinkedList-Klasse, die die Queue-Schnittstelle implementiert, um ein Warteschlangenobjekt zu erstellen.
Ebenso können wir eine Warteschlange mit anderen konkreten Klassen erstellen.
Queue str_pqueue = new PriorityQueue (); Queue int_queue = new ArrayDeque ();
Nachdem das Warteschlangenobjekt erstellt wurde, können wir das Warteschlangenobjekt initialisieren, indem wir ihm die Werte über die unten gezeigte add-Methode bereitstellen.
str_queue.add(“one”); str_queue.add(“two”); str_queue.add(“three”);
Beispiel für eine Java-Warteschlange
import java.util.*; public class Main { public static void main(String[] args) { //declare a Queue Queue str_queue = new LinkedList(); //initialize the queue with values str_queue.add('one'); str_queue.add('two'); str_queue.add('three'); str_queue.add('four'); //print the Queue System.out.println('The Queue contents:' + str_queue); } }
Ausgabe:
Der Inhalt der Warteschlange: [eins, zwei, drei, vier]
Das obige Beispiel zeigt die Deklaration und Initialisierung eines Queue-Objekts. Dann drucken wir einfach den Inhalt der Warteschlange.
Warteschlangenmethoden in Java
In diesem Abschnitt werden die API-Methoden für die Warteschlange erläutert. Die Warteschlangenschnittstelle unterstützt verschiedene Vorgänge wie Einfügen, Löschen, Durchsuchen usw. Einige Vorgänge lösen eine Ausnahme aus, während andere einen bestimmten Wert zurückgeben, wenn die Methode erfolgreich ist oder fehlschlägt.
Beachten Sie, dass in Java 8 keine spezifischen Änderungen an der Warteschlangensammlung vorgenommen wurden. Die folgenden Methoden sind auch in späteren Versionen von Java wie Java 9 usw. verfügbar.
Die folgende Tabelle fasst alle diese Methoden zusammen.
Methode | Methodenprototyp | Beschreibung |
---|---|---|
Größe | int size () | Gibt die Größe oder Anzahl der Elemente in der Warteschlange zurück. |
hinzufügen | Boolesches Addieren (E e) | Fügt der Warteschlange am Ende (Ende) der Warteschlange das Element e hinzu, ohne die Kapazitätsbeschränkungen zu verletzen. Gibt true zurück, wenn der Erfolg erfolgreich ist, oder IllegalStateException, wenn die Kapazität erschöpft ist. |
spähen | E peek () | Gibt den Kopf (vorne) der Warteschlange zurück, ohne ihn zu entfernen. |
Element | E Element () | Führt den gleichen Vorgang wie die peek () -Methode aus. Löst eine NoSuchElementException aus, wenn die Warteschlange leer ist. |
entfernen | E entferne () | Entfernt den Kopf der Warteschlange und gibt ihn zurück. Löst eine NoSuchElementException aus, wenn die Warteschlange leer ist. |
Umfrage | E Umfrage () | Entfernt den Kopf der Warteschlange und gibt ihn zurück. Wenn die Warteschlange leer ist, wird null zurückgegeben. |
Angebot | Boolesches Angebot (E e) | Fügen Sie das neue Element e in die Warteschlange ein, ohne die Kapazitätsbeschränkungen zu verletzen. |
Iterieren der Warteschlangenelemente
Wir können die Warteschlangenelemente entweder mit der forEach-Schleife oder mit einem Iterator durchlaufen. Das unten angegebene Programm implementiert beide Ansätze zum Durchlaufen der Warteschlange.
import java.util.*; public class Main { public static void main(String[] args) { //declare a Queue Queue LL_queue = new LinkedList(); //initialize the Queue LL_queue.add('Value-0'); LL_queue.add('Value-1'); LL_queue.add('Value-2'); LL_queue.add('Value-3'); //traverse the Queue using Iterator System.out.println('The Queue elements through iterator:'); Iterator iterator = LL_queue.iterator(); while(iterator.hasNext()){ String element = (String) iterator.next(); System.out.print(element + ' '); } System.out.println('
The Queue elements using for loop:'); //use new for loop to traverse the Queue for(Object object : LL_queue) { String element = (String) object; System.out.print(element + ' '); } } }
Ausgabe:
Die Queue-Elemente durch Iterator:
Wert-0 Wert-1 Wert-2 Wert-3
Die Warteschlangenelemente, die die for-Schleife verwenden:
Wert-0 Wert-1 Wert-2 Wert-3
Implementierung der Java-Warteschlange
Das folgende Programm demonstriert die oben diskutierten Methoden.
import java.util.*; public class Main { public static void main(String[] args) { Queue q1 = new LinkedList(); //Add elements to the Queue q1.add(10); q1.add(20); q1.add(30); q1.add(40); q1.add(50); System.out.println('Elements in Queue:'+q1); //remove () method =>removes first element from the queue System.out.println('Element removed from the queue: '+q1.remove()); //element() => returns head of the queue System.out.println('Head of the queue: '+q1.element()); //poll () => removes and returns the head System.out.println('Poll():Returned Head of the queue: '+q1.poll()); //returns head of the queue System.out.println('peek():Head of the queue: '+q1.peek()); //print the contents of the Queue System.out.println('Final Queue:'+q1); } }
Ausgabe:
Elemente in der Warteschlange: [10, 20, 30, 40, 50]
Aus der Warteschlange entferntes Element: 10
Leiter der Warteschlange: 20
Umfrage (): Zurückgegebener Leiter der Warteschlange: 20
peek (): Kopf der Warteschlange: 30
Letzte Warteschlange: [30, 40, 50]
Fragen zum Penetrationstest für Webanwendungen
Java Queue Array-Implementierung
Die Implementierung der Warteschlange ist nicht so einfach wie die Implementierung eines Stacks. Zunächst enthält die Warteschlange zwei Zeiger, hinten und vorne. Außerdem werden verschiedene Operationen an zwei verschiedenen Enden ausgeführt.
Um eine Warteschlange mithilfe von Arrays zu implementieren, deklarieren wir zunächst ein Array, das n Anzahl von Warteschlangenelementen enthält.
Dann definieren wir die folgenden Operationen, die in dieser Warteschlange ausgeführt werden sollen.
# 1) Enqueue: Eine Operation zum Einfügen eines Elements in die Warteschlange ist Enqueue (Funktion queueEnqueue im Programm). Um ein Element am hinteren Ende einzufügen, müssen wir zuerst prüfen, ob die Warteschlange voll ist. Wenn es voll ist, können wir das Element nicht einfügen. Wenn hinten # 2) Warteschlange: Die Operation zum Löschen eines Elements aus der Warteschlange ist Dequeue (Funktion queueDequeue im Programm). Zuerst prüfen wir, ob die Warteschlange leer ist. Damit die Warteschlangenoperation funktioniert, muss sich mindestens ein Element in der Warteschlange befinden. # 3) Vorderseite: Diese Methode gibt die Vorderseite der Warteschlange zurück. # 4) Anzeige: Diese Methode durchläuft die Warteschlange und zeigt die Elemente der Warteschlange an. Das folgende Java-Programm demonstriert die Array-Implementierung von Queue. Ausgabe: Anfangswarteschlange: Da wir die Warteschlangendatenstruktur mithilfe von Arrays im obigen Programm implementiert haben, können wir die Warteschlange auch mithilfe der verknüpften Liste implementieren. Wir werden die gleichen Methoden enqueue, dequeue, front und display in diesem Programm implementieren. Der Unterschied besteht darin, dass wir anstelle von Array die Datenstruktur der verknüpften Liste verwenden. Das folgende Programm demonstriert die Implementierung der verknüpften Liste von Queue in Java. Ausgabe: Element 6 zur Warteschlange hinzugefügt BlockingQueue ist eine in Java 1.5 hinzugefügte Schnittstelle und Teil der java.util.concurrent Paket. Diese Schnittstelle führt das Blockieren ein, falls die BlockingQueue voll oder leer ist. Wenn ein Thread auf die Warteschlange zugreift und versucht, Elemente in eine Warteschlange einzufügen (in die Warteschlange zu stellen), die bereits voll ist, wird dies blockiert, bis ein anderer Thread einen Platz in der Warteschlange erstellt (möglicherweise durch Entfernen der Warteschlange oder Löschen der Warteschlange). In ähnlicher Weise wird im Fall der Warteschlange die Operation blockiert, wenn die Warteschlange leer ist, bis das Element für die Warteschlangenoperation verfügbar wird. Die BlockingQueue-Methoden verwenden eine Form der Parallelitätskontrolle wie interne Sperren und sind atomar. Die BlockingQueue ist eine gleichzeitige Warteschlange, die die Warteschlangenoperationen gleichzeitig verwaltet. Die BlockingQueue wird unten angezeigt: Beachten Sie, dass BlockingQueue keine Nullwerte akzeptiert. Ein Versuch, einen Nullwert in die Warteschlange einzufügen, führt zu NullPointerException. Einige der in Java bereitgestellten BlockingQueue-Implementierungen sind LinkedBlockingQueue, PriorityBlockingQueue, ArrayBlockingQueue und SynchonousQueue. Alle diese Implementierungen sind threadsicher. Es gibt zwei Arten von BlockingQueues: In der begrenzten Warteschlange wird die Kapazität der Warteschlange an den Konstruktor der Warteschlange übergeben. Die Warteschlangendeklaration lautet wie folgt: BlockingQueue blockingQueue = new LinkedBlockingDeque (5); In der unbegrenzten Warteschlange legen wir die Kapazität der Warteschlange nicht explizit fest und sie kann an Größe zunehmen. Die Kapazität ist auf Integer.MAX_VALUE festgelegt. Die Deklaration der unbegrenzten Warteschlange lautet wie folgt: BlockingQueue blockingQueue = new LinkedBlockingDeque (); Die BlockingQueue-Schnittstelle wird hauptsächlich für Probleme zwischen Hersteller und Verbraucher verwendet, bei denen der Hersteller die Ressourcen produziert und der Verbraucher die Ressourcen verbraucht. F # 1) Was ist eine Warteschlange in Java? Antworten: Die Warteschlange in Java ist eine linear geordnete Datenstruktur, die der FIFO-Reihenfolge (First In, First Out) der Elemente folgt. Dies bedeutet, dass das zuerst in die Warteschlange eingefügte Element das erste zu entfernende Element ist. In Java wird die Warteschlange als Schnittstelle implementiert, die die Collection-Schnittstelle erbt. Q # 2) Ist ein Queue-Thread-sicheres Java? Antworten: Nicht alle Warteschlangen sind threadsicher, aber BlockingQueues in Java sind threadsicher. Q # 3) Was ist schneller - Stapel oder Warteschlange? Antworten: Der Stapel ist schneller. Im Stapel werden die Elemente nur von einem Ende verarbeitet, daher ist keine Verschiebung erforderlich. In der Warteschlange müssen die Elemente jedoch verschoben und angepasst werden, da zwei verschiedene Zeiger zum Einfügen und Löschen von Elementen vorhanden sind. Q # 4) Was sind die Arten der Warteschlange? Antwort: Es gibt folgende Arten von Warteschlangen: Q # 5) Warum wird die Warteschlange verwendet? Antworten: Die Warteschlangendatenstruktur wird für Synchronisationszwecke verwendet. Die Warteschlange wird auch für die Festplatten- und CPU-Planung verwendet. In diesem Tutorial haben wir die einfachen Warteschlangen mit ihren Details wie Deklarationen, Implementierung der Initialisierung und Methoden erläutert. Wir haben auch etwas über die Array- und LinkedList-Implementierung von Queue in Java gelernt. In unseren nächsten Tutorials werden wir weitere Arten von Warteschlangen im Detail besprechen. => Überprüfen Sie ALLE Java-Tutorials hier. class Queue { private static int front, rear, capacity; private static int queue[]; Queue(int size) { front = rear = 0; capacity = size; queue = new int[capacity]; } // insert an element into the queue static void queueEnqueue(int item) { // check if the queue is full if (capacity == rear) { System.out.printf('
Queue is full
'); return; } // insert element at the rear else { queue[rear] = item; rear++; } return; } //remove an element from the queue static void queueDequeue() { // check if queue is empty if (front == rear) { System.out.printf('
Queue is empty
'); return; } // shift elements to the right by one place uptil rear else { for (int i = 0; i
Wie erstelle ich ein String-Array?
Warteschlange ist leer
Warteschlange nach dem Einreihen:
10 = 30 = 50 = 70 =
Vorderes Element der Warteschlange: 10
Die Warteschlange ist voll
10 = 30 = 50 = 70 =
Warteschlange nach zwei Warteschlangenoperationen: 50 = 70 =
Vorderes Element der Warteschlange: 50Implementierung einer verknüpften Java-Warteschlangenliste
class LinkedListQueue { private Node front, rear; private int queueSize; // queue size //linked list node private class Node { int data; Node next; } //default constructor - initially front & rear are null; size=0; queue is empty public LinkedListQueue() { front = null; rear = null; queueSize = 0; } //check if the queue is empty public boolean isEmpty() { return (queueSize == 0); } //Remove item from the front of the queue. public int dequeue() { int data = front.data; front = front.next; if (isEmpty()) { rear = null; } queueSize--; System.out.println('Element ' + data+ ' removed from the queue'); return data; } //Add data at the rear of the queue. public void enqueue(int data) { Node oldRear = rear; rear = new Node(); rear.data = data; rear.next = null; if (isEmpty()) { front = rear; } else { oldRear.next = rear; } queueSize++; System.out.println('Element ' + data+ ' added to the queue'); } //print front and rear of the queue public void print_frontRear() { System.out.println('Front of the queue:' + front.data + ' Rear of the queue:' + rear.data); } } class Main{ public static void main(String a[]){ LinkedListQueue queue = new LinkedListQueue(); queue.enqueue(6); queue.enqueue(3); queue.print_frontRear(); queue.enqueue(12); queue.enqueue(24); queue.dequeue(); queue.dequeue(); queue.enqueue(9); queue.print_frontRear(); } }
Element 3 zur Warteschlange hinzugefügt
Vorderseite der Warteschlange: 6 Rückseite der Warteschlange: 3
Element 12 zur Warteschlange hinzugefügt
Element 24 zur Warteschlange hinzugefügt
Element 6 aus der Warteschlange entfernt
Element 3 aus der Warteschlange entfernt
Element 9 zur Warteschlange hinzugefügt
Vorderseite der Warteschlange: 12 Rückseite der Warteschlange: 9BlockingQueue In Java
BlockingQueue-Typen
Begrenzte Warteschlange
Ungebundene Warteschlange
Häufig gestellte Fragen
Fazit
Literatur-Empfehlungen