java queue queue methods
I denne vejledning diskuterer vi, hvad der er en kø i Java, hvordan man bruger den, Java-køeksempel, Java-kømetoder og kø-interfaceimplementering:
En kø er en lineær datastruktur eller en samling i Java, der gemmer elementer i en FIFO-rækkefølge (First In, First Out).
Køsamlingen har to ender, dvs. for og bag. Elementerne tilføjes bagpå og fjernes fra fronten.
=> Besøg her for at se Java Training Series for alle.
Hvad du lærer:
Hvad er en Java-kø?
En kødatastruktur er repræsenteret som vist nedenfor:
Som vist i ovenstående diagram er en kø en struktur med to punkter, dvs. start (forreste) og ende (bageste). Elementer indsættes i køen i den bageste ende og fjernes fra køen foran.
I Java er kø en grænseflade, der er en del af java.util-pakken. Køgrænsefladen udvider Java Collection-grænsefladen.
Den generelle definition af køgrænsefladen er:
public interface Queue extends Collection
Da køen er en grænseflade, kan den ikke instantieres. Vi har brug for nogle konkrete klasser for at implementere funktionaliteten i køgrænsefladen. To klasser implementerer køgrænsefladen, dvs. LinkedList og PriorityQueue.
Følgende er nogle af de vigtigste egenskaber ved kødatastrukturen:
- Kø følger FIFO-ordren (First In, First Out). Dette betyder, at elementet indsættes i køen i slutningen og fjernes fra køen i starten.
- Java-køgrænsefladen giver alle metoderne til samlinggrænseflade som indsættelse, sletning osv.
- LinkedList og PriorityQueue er de klasser, der implementerer køgrænsefladen. ArrayBlockingQueue er endnu en klasse, der implementerer køgrænsefladen.
- Køerne, der er en del af pakken java.util, kan klassificeres som ubegrænsede køer, mens de, der er til stede i java.util. Den samtidige pakke, er afgrænsede køer.
- Deque er en kø, der understøtter indsættelse og sletning fra begge ender.
- Dekket er trådsikkert.
- BlockingQueues er trådsikre og bruges til at implementere producent-forbrugerproblemer.
- BlockingQueues tillader ikke null-elementer. En NullPointerException smides, hvis der forsøges på en operation relateret til nulværdier.
Sådan bruges en kø i Java?
For at bruge en kø i Java skal vi først importere køgrænsefladen som følger:
import java.util.queue;
Eller
import java.util.*;
Når dette er importeret, kan vi oprette en kø som vist nedenfor:
Queue str_queue = new LinkedList ();
Da kø er en grænseflade, bruger vi en LinkedList-klasse, der implementerer køgrænsefladen til at oprette et køobjekt.
På samme måde kan vi oprette en kø med andre konkrete klasser.
Queue str_pqueue = new PriorityQueue (); Queue int_queue = new ArrayDeque ();
Nu hvor køobjektet er oprettet, kan vi initialisere køobjektet ved at give værdierne til det gennem tilføjelsesmetoden som vist nedenfor.
str_queue.add(“one”); str_queue.add(“two”); str_queue.add(“three”);
Eksempel på Java-kø
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); } }
Produktion:
Køens indhold: [en, to, tre, fire]
Ovenstående eksempel viser erklæringen og initialiseringen af et køobjekt. Derefter udskriver vi bare indholdet af køen.
Kømetoder i Java
I dette afsnit vil vi diskutere metoderne til API til køen. Køgrænseflade understøtter forskellige operationer som indsæt, slet, kig osv. Nogle operationer giver en undtagelse, mens nogle returnerer en bestemt værdi, når metoden lykkes eller mislykkes.
Bemærk, at der ikke er nogen specifikke ændringer i køsamlingen i Java 8. Nedenstående metoder er også tilgængelige i senere versioner af Java som Java 9 osv.
Nedenstående tabel opsummerer alle disse metoder.
Metode | Metode Prototype | Beskrivelse |
---|---|---|
størrelse | int størrelse () | Returnerer størrelsen eller antallet af elementer i køen. |
tilføje | boolsk tilføjelse (E e) | Føjer element e til køen i slutningen (halen) af køen uden at krænke begrænsningerne på kapaciteten. Returnerer sandt, hvis succes eller IllegalStateException, hvis kapaciteten er opbrugt. |
kigge | E kigger () | Returnerer køets hoved (forrest) uden at fjerne det. |
element | E-element () | Udfører den samme handling som peek () -metoden. Kaster NoSuchElementException, når køen er tom. |
fjerne | E fjern () | Fjerner køens hoved og returnerer det. Kaster NoSuchElementException, hvis køen er tom. |
afstemning | E-afstemning () | Fjerner køens hoved og returnerer det. Hvis køen er tom, returnerer den nul. |
Tilbud | boolsk tilbud (E e) | Indsæt det nye element e i køen uden at overtræde kapacitetsbegrænsninger. |
Iterering af køelementerne
Vi kan krydse køelementerne enten ved hjælp af forEach-sløjfen eller ved hjælp af en iterator. Programmet nedenfor implementerer begge tilgange til at krydse køen.
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 + ' '); } } }
Produktion:
Køelementerne gennem iterator:
Værdi-0 Værdi-1 Værdi-2 Værdi-3
Køelementerne ved hjælp af for loop:
Værdi-0 Værdi-1 Værdi-2 Værdi-3
Implementering af Java-kø
Programmet nedenfor viser de metoder, som vi diskuterede ovenfor.
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); } }
Produktion:
Elementer i kø: [10, 20, 30, 40, 50]
Element fjernet fra køen: 10
Køhoved: 20
Afstemning (): Returneret køhoved: 20
kig (): Køhoved: 30
Endelig kø: [30, 40, 50]
Implementering af Java-køarray
Køimplementering er ikke så ligetil som en stakimplementering. Først og fremmest indeholder køen to markører, bagpå og foran. Også forskellige operationer udføres i to forskellige ender.
For at implementere kø ved hjælp af Arrays erklærer vi først et array, der indeholder n antal køelementer.
Derefter definerer vi følgende operationer, der skal udføres i denne kø.
# 1) Enqueue: En handling til at indsætte et element i køen er Enqueue (funktionskøEnqueue i programmet). For at indsætte et element i bagenden skal vi først kontrollere, om køen er fuld. Hvis den er fuld, kan vi ikke indsætte elementet. Hvis bagpå # 2) Dequeue: Funktionen til at slette et element fra køen er Dequeue (funktionskøDequeue i programmet). Først kontrollerer vi, om køen er tom. For at dequeue-drift skal fungere, skal der være mindst et element i køen. # 3) Front: Denne metode returnerer fronten af køen. # 4) Skærm: Denne metode krydser køen og viser køens elementer. Følgende Java-program demonstrerer Array-implementeringen af kø. Produktion: Indledende kø: Da vi har implementeret kødatastrukturen ved hjælp af Arrays i ovenstående program, kan vi også implementere køen ved hjælp af Linked List. Vi implementerer de samme metoder enqueue, dequeue, front og display i dette program. Forskellen er, at vi vil bruge datastrukturen for den linkede liste i stedet for Array. Nedenstående program demonstrerer implementeringen af den sammenkædede liste af kø i Java. Produktion: Element 6 tilføjet til køen BlockingQueue er en grænseflade tilføjet i Java 1.5 og er en del af java.util.concurrent pakke. Denne grænseflade introducerer blokering, hvis BlockingQueue er fuld eller tom. Når en tråd således får adgang til køen og forsøger at indsætte (enqueue) -elementer i en kø, der allerede er fuld, blokeres, indtil en anden tråd skaber et mellemrum i køen (måske ved afkørsel eller rydningskø). På samme måde blokeres operationen i tilfælde af dequeuing, hvis køen er tom, indtil elementet bliver tilgængeligt til dequeue-operationen. BlockingQueue-metoderne bruger en eller anden form for samtidighedskontrol som interne låse og er atomare. BlockingQueue er en samtidig kø, der administrerer køoperationerne samtidigt. BlockingQueue vises nedenfor: Bemærk, at BlockingQueue ikke accepterer nulværdier. Et forsøg på at indsætte en nulværdi i køen resulterer i NullPointerException. Nogle af de BlockingQueue-implementeringer, der leveres i Java, er LinkedBlockingQueue, PriorityBlockingQueue, ArrayBlockingQueue og SynchonousQueue. Alle disse implementeringer er trådsikre. BlockingQueues er af to typer: I den afgrænsede kø overføres køens kapacitet til køens konstruktør. Køerklæringen er som følger: BlockingQueue blockingQueue = ny LinkedBlockingDeque (5); I den ubegrænsede kø indstiller vi ikke eksplicit køens kapacitet, og den kan vokse i størrelse. Kapaciteten er indstillet til Integer.MAX_VALUE. Erklæringen om den ubegrænsede kø er som følger: BlockingQueue blockingQueue = ny LinkedBlockingDeque (); BlockingQueue-grænsefladen bruges primært til producent-forbruger-typer problemer, hvor producenten producerer ressourcerne, og forbrugeren bruger ressourcerne. Q # 1) Hvad er en kø i Java? Svar: Kø i Java er en lineær ordnet datastruktur, der følger FIFO (First In, First Out) -bestilling af elementer. Dette betyder, at det element, der indsættes først i køen, vil være det første element, der fjernes. I Java implementeres køen som en grænseflade, der arver Collection-grænsefladen. Q # 2) Er en køtrådsikker Java? Svar: Ikke alle køer er trådsikre, men BlockingQueues i Java er trådsikre. Q # 3) Hvilket er hurtigere - stak eller kø? Svar: Stakken er hurtigere. I stakken behandles elementerne kun fra den ene ende, hvorfor der ikke kræves nogen forskydning. Men i køen skal elementerne skiftes og justeres, da der er to forskellige markører, der skal indsættes og slettes. Q # 4) Hvad er typerne i køen? Svar: Køerne er af følgende typer: Q # 5) Hvorfor bruges køen? Svar: Kø-datastrukturen bruges til synkroniseringsformål. Køen bruges også til planlægning af disk og CPU. I denne vejledning har vi diskuteret de enkle køer sammen med deres detaljer som erklæringer, implementering af initialisering og metoder. Vi lærte også om Array- og LinkedList-implementeringen af Kø i Java. I vores kommende tutorials vil vi diskutere flere typer køer i detaljer. => Tjek ALLE Java-tutorials her. hvad er en god gratis pc-renser
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
Køen er tom
Kø efter Enqueue-drift:
10 = 30 = 50 = 70 =
Køens forreste element: 10
Køen er fuld
10 = 30 = 50 = 70 =
Kø efter to dequeue-operationer: 50 = 70 =
Køens forreste element: 50Implementering af Java-kø-tilknyttet liste
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 tilføjet til køen
Køens forreste: 6 Køens bageste: 3
Element 12 føjet til køen
Element 24 tilføjet til køen
Element 6 fjernet fra køen
Element 3 fjernet fra køen
Element 9 føjet til køen
Køens forside: 12 Køens bageste: 9BlockingQueue i Java
BlockingQueue-typer
Afgrænset kø
Ubegrænset kø
Ofte stillede spørgsmål
Konklusion
Anbefalet læsning