En kö är en annan typ av linjär datastruktur som används för att lagra element precis som alla andra datastrukturer men på ett speciellt sätt. Med enkla ord kan vi säga att kön är en typ av datastruktur i programmeringsspråket Java som lagrar element av samma slag. Komponenterna i en kö lagras i ett FIFO-beteende (First In, First Out). Det finns två ändar i kösamlingen, d.v.s. fram och bak. Kön har två ändar som är fram och bak.

Följande figur beskriver perfekt egenskapen FIFO (First In, First Out) för Java-kön.

java delsträng

Som förklarats i föregående bild kan vi se att kön är en linjär datastruktur med två terminaler, dvs start (fram) och slut (bak). Komponenter läggs in i kön från den bakre änden av kön och komponenterna extraheras från den främre änden av kön.

Kön är ett gränssnitt i Java som tillhör Java.util-paketet. Det utökar också samlingsgränssnittet.

Den allmänna representationen av Java Queue-gränssnittet visas nedan:

 public interface Queue extends Collection 

Som vi har diskuterat ovan att kön är ett gränssnitt, därför kan vi också säga att kön inte kan instansieras eftersom gränssnitt inte kan instansieras. Om en användare vill implementera funktionaliteten hos Queue-gränssnittet i Java, är det obligatoriskt att ha några solida klasser som implementerar Queue-gränssnittet.

I programmeringsspråket Java finns det två olika klasser som används för att implementera Queue-gränssnittet. Dessa klasser är:

• Länkad lista
• Prioritetskö

Egenskaper för Java-kön

Java-kön kan betraktas som en av de viktigaste datastrukturerna i programmeringsvärlden. Java Queue är attraktiv på grund av dess egenskaper. De betydande egenskaperna hos Java Queue-datastrukturen ges enligt följande:

• Java Queue följer FIFO-sättet (först in, först ut). Det indikerar att element läggs in i kön i slutet och elimineras framifrån.
• Java Queue-gränssnittet ger alla regler och processer för samlingsgränssnittet som inkludering, radering, etc.
• Det finns två olika klasser som används för att implementera Queue-gränssnittet. Dessa klasser är LinkedList och PriorityQueue.
• Förutom dessa två finns det en klass som är Array Blocking Queue som används för att implementera Queue-gränssnittet.
• Det finns två typer av köer, obegränsade köer och begränsade köer. Köerna som är en del av java.util-paketet är kända som Unbounded queues och bounded queues är de köer som finns i java.util.concurrent-paketet.
• Deque eller (dubbelkön) är också en typ av kö som innehåller inkludering och radering av element från båda ändarna.
• Dequen anses också vara gängsäker.
• Blockeringsköer är också en av de typer av köer som också är trådsäkra. Blockeringsköerna används för att implementera producent-konsumentfrågor.
• Blockeringsköer stöder inte null-element. I blockeringsköer, om något arbete som liknar null-värden prövas, kastas även NullPointerException.

Implementering av kö

Klasser som används vid implementering av Queue

Klasserna som används för att implementera köns funktioner ges enligt följande:

• ArrayDeque
• Länkad lista
• Prioritetskö

Gränssnitt som används vid implementering av Queue

Java-gränssnitten används också i implementeringen av Java-kön. Gränssnitten som används för att implementera köns funktioner ges enligt följande:

• Om vad
• Blockerande kö
• Blockerande Deque

Java Queue Class Methods

I Java-kön finns det många metoder som används mycket vanligt. Kögränssnittet främjar olika metoder som infoga, ta bort, kika, etc. Vissa operationer i Java-kön ger upphov till ett undantag medan vissa av dessa operationer returnerar ett visst värde när programmet är klart.

Obs - I Java SE 8 görs inga ändringar i Java-kösamlingen. Dessa metoder som definieras under är ytterligare förberedda i de efterföljande versionerna av programmeringsspråket Java. Till exempel Java SE 9.

Olika metoder för Java Queue definieras nedan:

Implementering av Java Queue Array

Köimplementering är inte lika enkelt som en stackimplementering.

För att implementera kö med Arrays, deklarerar vi först en array som innehåller n antal element.

Sedan definierar vi följande operationer som ska utföras i denna kö.

användning av operativsystem

1) Kö: En operation för att infoga ett element i kön är Enqueue (funktionskö Enqueue i programmet). För att infoga ett element på baksidan måste vi först kontrollera om kön är full. Om det är fullt kan vi inte infoga elementet. Om bak

2) Svans: Åtgärden för att ta bort ett element från kön är Dequeue (funktionskö Dequeue i programmet). Först kontrollerar vi om kön är tom. För att ködrift ska fungera måste det finnas minst ett element i kön.

3) Framsidan: Denna metod returnerar den främre delen av kön.

4) Display: Denna metod går igenom kön och visar köns element.

Java Queue Program

Följande Java-program demonstrerar implementeringen av 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>

Implementering av Java Queue Linked List

Eftersom vi har implementerat Queue-datastrukturen med hjälp av Arrays i programmet ovan, kan vi även implementera Queue med hjälp av länkad lista.

java if else-sats

Vi kommer att implementera samma metoder enqueue, dequeue, front och display i det här programmet. Skillnaden är att vi kommer att använda den länkade listans datastruktur istället för Array.

Nedanstående program demonstrerar Linked List-implementeringen av Queue i 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(); } } 

Produktion:

 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