Kolejka to inny rodzaj liniowej struktury danych, która służy do przechowywania elementów tak jak każda inna struktura danych, ale w określony sposób. W prostych słowach możemy powiedzieć, że kolejka jest rodzajem struktury danych w języku programowania Java, która przechowuje elementy tego samego rodzaju. Komponenty w kolejce są przechowywane w oparciu o zasadę FIFO (pierwsze weszło, pierwsze wyszło). Kolejka ma dwa końce, tj. przód i tył. Kolejka ma dwa końce, przedni i tylny.

Poniższy rysunek doskonale opisuje właściwość FIFO (First In, First Out) kolejki Java.

Jak wyjaśniono na poprzednim obrazie, możemy zobaczyć, że kolejka jest liniową strukturą danych z dwoma terminalami, tj. początkiem (przód) i końcem (tył). Komponenty są dodawane do kolejki z tylnego końca kolejki, a komponenty są wyodrębniane z przedniego końca kolejki.

Kolejka jest interfejsem w Jawa należący do pakietu Java.util. Rozszerza także interfejs Kolekcji.

Ogólna reprezentacja interfejsu kolejki Java jest pokazana poniżej:

lista Javy

 public interface Queue extends Collection 

Jak omówiliśmy powyżej, kolejka jest interfejsem, dlatego możemy również powiedzieć, że nie można utworzyć instancji kolejki, ponieważ nie można utworzyć instancji interfejsów. Jeśli użytkownik chce zaimplementować funkcjonalność interfejsu Queue w Javie, obowiązkowe jest posiadanie solidnych klas implementujących interfejs Queue.

W języku programowania Java istnieją dwie różne klasy używane do implementacji interfejsu kolejki. Te klasy to:

jak działa komputer

• Połączona lista
• Kolejka priorytetowa

Charakterystyka kolejki Java

Kolejkę Java można uznać za jedną z najważniejszych struktur danych w świecie programowania. Kolejka Java jest atrakcyjna ze względu na swoje właściwości. Istotne właściwości struktury danych kolejki Java podano w następujący sposób:

• Kolejka Java przestrzega zasady FIFO (pierwsze weszło, pierwsze wyszło). Oznacza to, że elementy wprowadzane są do kolejki na końcu i eliminowane z przodu.
• Interfejs Java Queue udostępnia wszystkie reguły i procesy interfejsu Collection, takie jak włączanie, usuwanie itp.
• Istnieją dwie różne klasy używane do implementacji interfejsu kolejki. Te klasy to LinkedList i PriorityQueue.
• Oprócz tych dwóch istnieje klasa Array Blocking Queue, która służy do implementacji interfejsu kolejki.
• Istnieją dwa typy kolejek: kolejki nieograniczone i kolejki ograniczone. Kolejki będące częścią pakietu java.util nazywane są kolejkami nieograniczonymi, a kolejki ograniczone to kolejki obecne w pakiecie java.util.concurrent.
• Deque lub (kolejka dwustronna) to także rodzaj kolejki, która umożliwia włączanie i usuwanie elementów z obu końców.
• Deque jest również uważane za bezpieczne dla wątków.
• Kolejki blokujące są również jednym z typów kolejek, które są również bezpieczne dla wątków. Kolejki blokujące służą do realizacji zapytań producent-konsument.
• Kolejki blokujące nie obsługują elementów null. Jeśli w kolejkach blokujących zostanie podjęta próba działania podobnego do wartości null, zostanie również zgłoszony wyjątek NullPointerException.

Implementacja kolejki

Klasy używane w implementacji Queue

Klasy służące do implementacji funkcjonalności kolejki podano następująco:

• TablicaDeque
• Połączona lista
• Kolejka priorytetowa

Interfejsy użyte w implementacji Queue

Interfejsy Java są również wykorzystywane przy implementacji kolejki Java. Interfejsy służące do realizacji funkcjonalności kolejki podano następująco:

• O czym
• Blokowanie kolejki
• Blokowanie Deque

Metody klas kolejki Java

W kolejce Java istnieje wiele metod, które są bardzo często używane. Interfejs Queue obsługuje różne metody, takie jak wstawianie, usuwanie, podgląd itp. Niektóre operacje wykonywane w kolejce Java zgłaszają wyjątek, podczas gdy niektóre z tych operacji zwracają określoną wartość po zakończeniu programu.

Uwaga — w wersji Java SE 8 nie wprowadzono żadnych zmian w zbiorze kolejek Java. Metody te, które są zdefiniowane poniżej, są dalej opracowywane w kolejnych wersjach języka programowania Java. Na przykład Java SE 9.

Poniżej zdefiniowano różne metody kolejki Java:

Implementacja tablicy kolejek Java

Implementacja kolejki nie jest tak prosta jak implementacja stosu.

Aby zaimplementować kolejkę za pomocą tablic, najpierw deklarujemy tablicę zawierającą n elementów.

przycinanie JavaScriptu

Następnie definiujemy następujące operacje, które mają zostać wykonane w tej kolejce.

1) Kolejka: Operacją wstawienia elementu do kolejki jest Enqueue (funkcja kolejki Enqueue w programie). Aby wstawić element na końcu, musimy najpierw sprawdzić, czy kolejka jest pełna. Jeżeli jest pełny to nie możemy wstawić elementu. Jeśli z tyłu

2) Ogon: Operacją usunięcia elementu z kolejki jest Dequeue (funkcja kolejki Dequeue w programie). Najpierw sprawdzamy, czy kolejka jest pusta. Aby operacja usuwania z kolejki zadziałała, w kolejce musi znajdować się co najmniej jeden element.

3) Przód: Ta metoda zwraca początek kolejki.

4) Wyświetlacz: Ta metoda przechodzi przez kolejkę i wyświetla elementy kolejki.

Program kolejkowy w Javie

Poniższy program Java demonstruje implementację Queue.

przykład przycinania alfa beta

QueueArrayImplementation.java

 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
&apos;); return; } // shift elements to the right by one place uptil rear else { for (int i = 0; i <rear 0 4 - 1; i++) { queue[i]="queue[i" + 1]; } set queue[rear] to if (rear < capacity) decrement rear rear--; return; print queue elements static void queuedisplay() int i; (front="=" rear) system.out.printf('queue is empty
'); traverse front and for (i="front;" i rear; system.out.printf(' %d , ', queue[i]); of queuefront() system.out.printf('
front element the queue: %d', queue[front]); public class queuearrayimplementation main(string[] args) create a capacity q="new" queue(4); system.out.println('initial queue:'); q.queuedisplay(); inserting in q.queueenqueue(10); q.queueenqueue(30); q.queueenqueue(50); q.queueenqueue(70); system.out.println('queue after enqueue operation:'); q.queuefront(); insert q.queueenqueue(90); q.queuedequeue(); system.out.printf('
queue two dequeue operations:'); pre> <p> <strong>Output:</strong> </p> <pre> Initial Queue: Queue is Empty Queue after Enqueue Operation: 10 , 30 , 50 , 70 , Front Element of the queue: 10 Queue is full 10 , 30 , 50 , 70 , Queue after two dequeue operations: 50 , 70 , Front Element of the queue: 50 </pre> <h2>Java Queue Linked List Implementation</h2> <p>As we have implemented the Queue data structure using Arrays in the above program, we can also implement the Queue using Linked List.</p> <p>We will implement the same methods enqueue, dequeue, front, and display in this program. The difference is that we will be using the Linked List data structure instead of Array.</p> <p>The below program demonstrates the Linked List implementation of Queue in Java.</p> <p> <strong>QueueLLImplementation.java</strong> </p> <pre> 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 &amp; 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(&apos;Element &apos; + data+ &apos; removed from the queue&apos;); 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(&apos;Element &apos; + data+ &apos; added to the queue&apos;); } //print front and rear of the queue public void print_frontRear() { System.out.println(&apos;Front of the queue:&apos; + front.data + &apos; Rear of the queue:&apos; + rear.data); } } class QueueLLImplementation{ 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(); } } </pre> <p> <strong>Output:</strong> </p> <pre> Element 6 added to the queue Element 3 added to the queue Front of the queue:6 Rear of the queue:3 Element 12 added to the queue Element 24 added to the queue Element 6 removed from the queue Element 3 removed from the queue Element 9 added to the queue Front of the queue:12 Rear of the queue:9 </pre> <hr></rear>

Implementacja listy połączonych kolejek Java

Ponieważ w powyższym programie zaimplementowaliśmy strukturę danych kolejki przy użyciu tablic, możemy również zaimplementować kolejkę przy użyciu listy połączonej.

W tym programie zaimplementujemy te same metody enqueue, dequeue, front i display. Różnica polega na tym, że będziemy używać struktury danych Linked List zamiast Array.

Poniższy program demonstruje implementację kolejki Linked List w Javie.

QueueLLImplementation.java

pierwszy laptop

 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 QueueLLImplementation{ 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(); } } 

Wyjście:

 Element 6 added to the queue Element 3 added to the queue Front of the queue:6 Rear of the queue:3 Element 12 added to the queue Element 24 added to the queue Element 6 removed from the queue Element 3 removed from the queue Element 9 added to the queue Front of the queue:12 Rear of the queue:9