Red čekanja je još jedna vrsta linearne podatkovne strukture koja se koristi za pohranu elemenata kao i svaka druga podatkovna struktura, ali na određeni način. Jednostavnim riječima, možemo reći da je red vrsta podatkovne strukture u programskom jeziku Java koja pohranjuje elemente iste vrste. Komponente u redu čekanja pohranjuju se u FIFO (First In, First Out) ponašanju. Postoje dva kraja skupljanja reda čekanja, tj. prednji i stražnji. Red ima dva kraja, prednji i stražnji.

arraylist java

Sljedeća slika savršeno opisuje svojstvo FIFO (First In, First Out) Java reda čekanja.

Kao što je objašnjeno na prethodnoj slici, možemo vidjeti da je red čekanja linearna struktura podataka s dva terminala, tj. početak (prednji) i kraj (stražnji). Komponente se dodaju unutar reda čekanja sa stražnjeg kraja reda čekanja, a komponente se izdvajaju s prednjeg kraja reda čekanja.

Red čekanja je sučelje u Java koji pripada paketu Java.util. Također proširuje sučelje zbirke.

Generički prikaz sučelja Java Queue prikazan je u nastavku:

 public interface Queue extends Collection 

Kao što smo već spomenuli da je red čekanja sučelje, stoga također možemo reći da se red ne može instancirati jer se sučelja ne mogu instancirati. Ako korisnik želi implementirati funkcionalnost Queue sučelja u Javi, tada je obavezno imati neke čvrste klase koje implementiraju Queue sučelje.

U programskom jeziku Java postoje dvije različite klase koje se koriste za implementaciju sučelja Queue. Ove klase su:

• LinkedList
• PriorityQueue

Karakteristike Java Queuea

Java Queue se može smatrati jednom od najvažnijih struktura podataka u svijetu programiranja. Java Queue je atraktivan zbog svojih svojstava. Značajna svojstva strukture podataka Java Queue dana su kako slijedi:

• Java Queue poštuje FIFO (prvi ušao, prvi izašao) način. Označava da su elementi uneseni u red čekanja na kraju i eliminirani s početka.
• Sučelje Java Queue daje sva pravila i procese sučelja Collection kao što su uključivanje, brisanje itd.
• Postoje dvije različite klase koje se koriste za implementaciju sučelja Queue. Ove klase su LinkedList i PriorityQueue.
• Osim ove dvije, postoji klasa koja je, Array Blocking Queue koja se koristi za implementaciju Queue sučelja.
• Postoje dvije vrste redova čekanja, neograničeni redovi čekanja i ograničeni redovi čekanja. Redovi koji su dio paketa java.util poznati su kao neograničeni redovi, a ograničeni redovi su redovi prisutni u paketu java.util.concurrent.
• Deque ili (double-ended queue) također je vrsta reda koja uključuje uključivanje i brisanje elemenata s oba kraja.
• Deque se također smatra niti sigurnim.
• Blokirajući redovi također su jedna od vrsta redova čekanja koji su također sigurni za niti. Redovi čekanja za blokiranje koriste se za implementaciju upita proizvođač-potrošač.
• Redovi čekanja za blokiranje ne podržavaju nulte elemente. U redovima čekanja za blokiranje, ako se pokuša bilo kakav rad sličan null vrijednostima, tada se također izbacuje iznimka NullPointerException.

Implementacija reda čekanja

Klase korištene u implementaciji Queuea

Klase koje se koriste za implementaciju funkcionalnosti reda dane su kako slijedi:

• ArrayDeque
• LinkedList
• PriorityQueue

Sučelja korištena u implementaciji Queuea

Java sučelja također se koriste u implementaciji Java reda čekanja. Sučelja koja se koriste za implementaciju funkcionalnosti reda dana su kako slijedi:

• O čemu
• Red čekanja za blokiranje
• Blokiranje Deque

Metode klase Java Queue

U Java redu čekanja postoje mnoge metode koje se vrlo često koriste. Sučelje Queue promiče različite metode kao što su umetanje, brisanje, peek, itd. Neke od operacija Java čekanja pokreću iznimku, dok neke od tih operacija vraćaju određenu vrijednost kada je program dovršen.

cijeli broj u niz u Javi

Napomena - U Javi SE 8 nema promjena u zbirci čekanja Java. Ove metode koje su definirane ispod dalje su pripremljene u narednim verzijama programskog jezika Java. Na primjer, Java SE 9.

Dolje su definirane različite metode Java Queuea:

Implementacija Java Queue Array

Implementacija reda čekanja nije tako jednostavna kao implementacija snopa.

Da bismo implementirali red čekanja pomoću nizova, prvo deklariramo niz koji sadrži n elemenata.

Zatim definiramo sljedeće operacije koje će se izvesti u ovom redu čekanja.

1) Stavite u red: Operacija za umetanje elementa u red je Enqueue (funkcija queue Enqueue u programu). Za umetanje elementa na stražnji kraj, prvo moramo provjeriti je li red čekanja pun. Ako je pun, ne možemo umetnuti element. Ako straga

2) Rep: Operacija brisanja elementa iz reda čekanja je Dequeue (funkcija queue Dequeue u programu). Prvo provjeravamo da li je red prazan. Da bi operacija uklanjanja iz reda radila, mora postojati barem jedan element u redu čekanja.

dodati nizu java

3) Prednja strana: Ova metoda vraća početak reda čekanja.

4) Prikaz: Ova metoda prolazi kroz red i prikazuje elemente reda.

Program Java Queue

Sljedeći Java program demonstrira implementaciju Queuea.

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>

Implementacija povezanog popisa Java Queuea

Kako smo u gornjem programu implementirali strukturu podataka Queue koristeći Arrays, možemo također implementirati Queue koristeći Linked List.

Implementirat ćemo iste metode stavljanja u red čekanja, uklanjanja iz reda čekanja, ispred i prikaza u ovom programu. Razlika je u tome što ćemo koristiti podatkovnu strukturu povezanog popisa umjesto polja.

string metode u Javi

Program u nastavku demonstrira implementaciju Queuea s povezanim popisom u Javi.

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

Izlaz:

 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