Опашката е друг вид линейна структура от данни, която се използва за съхраняване на елементи точно като всяка друга структура от данни, но по определен начин. С прости думи можем да кажем, че опашката е вид структура от данни в езика за програмиране Java, която съхранява елементи от същия вид. Компонентите в опашка се съхраняват в поведение FIFO (първи влязъл, първи излязъл). Има два края на колекцията от опашки, т.е. преден и заден. Опашката има два края, които са отпред и отзад.

Следващата фигура идеално описва свойството FIFO (First In, First Out) на опашката на Java.

Както е обяснено в предходното изображение, можем да видим, че опашката е линейна структура от данни с два терминала, т.е. начало (отпред) и край (отзад). Компонентите се добавят в опашката от задния край на опашката и компонентите се извличат от предния край на опашката.

Опашката е интерфейс в Java който принадлежи към пакета Java.util. Той също така разширява интерфейса на колекцията.

списък за сортиране на java

Общото представяне на интерфейса на Java Queue е показано по-долу:

 public interface Queue extends Collection 

Както обсъдихме по-горе, опашката е интерфейс, следователно можем също да кажем, че опашката не може да бъде инстанцирана, защото интерфейсите не могат да бъдат инстанцирани. Ако потребител иска да внедри функционалността на интерфейса Queue в Java, тогава е задължително да има някои солидни класове, които имплементират интерфейса Queue.

В езика за програмиране Java има два различни класа, които се използват за реализиране на интерфейса Queue. Тези класове са:

• LinkedList
• PriorityQueue

Характеристики на Java Queue

Java Queue може да се счита за една от най-важните структури от данни в света на програмирането. Java Queue е привлекателна поради своите свойства. Значимите свойства на структурата от данни на Java Queue са дадени, както следва:

• Java Queue се подчинява на FIFO (First In, First Out) начина. Показва, че елементите се въвеждат в опашката в края и се елиминират отпред.
• Интерфейсът на Java Queue предоставя всички правила и процеси на интерфейса за събиране, като включване, изтриване и т.н.
• Има два различни класа, които се използват за реализиране на интерфейса Queue. Тези класове са LinkedList и PriorityQueue.
• Освен тези два, има клас, който е Array Blocking Queue, който се използва за внедряване на интерфейса Queue.
• Има два вида опашки, неограничени опашки и ограничени опашки. Опашките, които са част от пакета java.util, са известни като неограничени опашки, а ограничените опашки са опашките, които присъстват в пакета java.util.concurrent.
• Deque или (опашка с двоен край) също е вид опашка, която включва включването и изтриването на елементи от двата края.
• Deque също се счита за безопасен за нишки.
• Блокиращите опашки също са един от видовете опашки, които също са безопасни за нишки. Блокиращите опашки се използват за изпълнение на заявките производител-потребител.
• Опашките за блокиране не поддържат нулеви елементи. В опашки за блокиране, ако се опита някаква работа, подобна на нулеви стойности, тогава NullPointerException също се хвърля.

Внедряване на опашка

Класове, използвани при внедряването на Queue

Класовете, които се използват за реализиране на функционалностите на опашката, са дадени, както следва:

• ArrayDeque
• LinkedList
• PriorityQueue

Интерфейси, използвани при внедряването на Queue

Java интерфейсите се използват и при реализацията на Java опашката. Интерфейсите, които се използват за реализиране на функционалностите на опашката, са дадени, както следва:

• За какво
• Опашка за блокиране
• Блокиране на Deque

Методи на Java Queue Class

В опашката на Java има много методи, които се използват много често. Интерфейсът Queue насърчава различни методи като вмъкване, изтриване, надникване и т.н. Някои от операциите на опашката на Java предизвикват изключение, докато някои от тези операции връщат определена стойност, когато програмата приключи.

Забележка – В Java SE 8 няма направени промени в колекцията от опашки на Java. Тези методи, които са дефинирани по-долу, са допълнително подготвени в следващите версии на езика за програмиране Java. Например Java SE 9.

Различните методи на Java Queue са дефинирани по-долу:

Реализация на Java Queue Array

Внедряването на опашката не е толкова лесно като изпълнението на стека.

За да реализираме опашка с помощта на масиви, първо декларираме масив, който съдържа n на брой елементи.

След това дефинираме следните операции, които да бъдат изпълнени в тази опашка.

1) Поставяне на опашка: Операция за вмъкване на елемент в опашката е Enqueue (функция queue Enqueue в програмата). За да вмъкнем елемент в задния край, първо трябва да проверим дали опашката е пълна. Ако е пълен, тогава не можем да вмъкнем елемента. Ако отзад

2) Опашка: Операцията за изтриване на елемент от опашката е Dequeue (функция queue Dequeue в програмата). Първо проверяваме дали опашката е празна. За да работи операцията за премахване на опашката, трябва да има поне един елемент в опашката.

3) Предна част: Този метод връща началото на опашката.

4) Дисплей: Този метод преминава през опашката и показва елементите на опашката.

Java Queue програма

Следната Java програма демонстрира изпълнението на Queue.

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>

Внедряване на свързан списък с Java Queue

Тъй като внедрихме структурата от данни на опашката, използвайки масиви в горната програма, можем също да внедрим опашката, използвайки свързан списък.

Ние ще приложим същите методи за поставяне в опашка, изваждане от опашка, отпред и показване в тази програма. Разликата е, че ще използваме структурата от данни на Linked List вместо Array.

Програмата по-долу демонстрира внедряването на свързан списък на опашка в Java.

QueueLLImplementation.java

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

Изход:

 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