java queue queue methods
I den här handledningen kommer vi att diskutera vad som är en kö i Java, hur man använder det, Java-köexempel, Java-kömetoder och kögränssnittsimplementering:
En kö är en linjär datastruktur eller en samling i Java som lagrar element i en FIFO-ordning (First In, First Out).
sql tentamen frågor och svar pdf
Köuppsamlingen har två ändar, dvs fram och bak. Elementen läggs till på baksidan och tas bort från framsidan.
=> Besök här för att se Java Training Series för alla.
Vad du kommer att lära dig:
Vad är en Java-kö?
En ködatastruktur representeras som visas nedan:
Som visas i ovanstående diagram är en kö en struktur med två punkter, dvs. start (fram) och slut (bak). Element sätts in i kön i den bakre änden och tas bort från kön framtill.
I Java är kö ett gränssnitt som ingår i paketet java.util. Kögränssnittet utökar Java Collection-gränssnittet.
Den allmänna definitionen av kögränssnittet är:
public interface Queue extends CollectionEftersom kön är ett gränssnitt kan den inte instantieras. Vi behöver några konkreta klasser för att implementera funktionerna i kögränssnittet. Två klasser implementerar kögränssnittet, dvs LinkedList och PriorityQueue.
Följande är några av de viktigaste egenskaperna för ködatastrukturen:
- Kön följer FIFO-ordern (First In, First Out). Detta innebär att elementet sätts in i kön i slutet och tas bort från kön i början.
- Java-kögränssnittet innehåller alla metoder för samlingsgränssnitt som insättning, radering etc.
- LinkedList och PriorityQueue är de klasser som implementerar kögränssnittet. ArrayBlockingQueue är ännu en klass som implementerar kögränssnittet.
- Köerna som ingår i paketet java.util kan klassificeras som obegränsade köer medan de som finns i java.util. det samtidiga paketet är avgränsade köer.
- Deque är en kö som stöder insättning och radering från båda ändarna.
- Dekket är trådsäkert.
- BlockingQueues är trådsäkra och används för att implementera producent-konsumentproblem.
- BlockingQueues tillåter inte null-element. En NullPointerException kastas om någon åtgärd relaterad till nollvärden försöks.
Hur man använder en kö i Java?
För att använda en kö i Java måste vi först importera kögränssnittet enligt följande:
import java.util.queue; Eller
import java.util.*; När detta har importerats kan vi skapa en kö enligt nedan:
Queue str_queue = new LinkedList (); Eftersom kö är ett gränssnitt använder vi en LinkedList-klass som implementerar kögränssnittet för att skapa ett köobjekt.
På samma sätt kan vi skapa en kö med andra konkreta klasser.
Queue str_pqueue = new PriorityQueue (); Queue int_queue = new ArrayDeque (); Nu när köobjektet har skapats kan vi initialisera köobjektet genom att tillhandahålla värdena till det genom att lägga till metoden som visas nedan.
str_queue.add(“one”); str_queue.add(“two”); str_queue.add(“three”);Exempel 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öinnehållet: (en, två, tre, fyra)
Ovanstående exempel visar deklarationen och initialiseringen av ett köobjekt. Sedan skriver vi bara ut innehållet i kön.
Kömetoder i Java
I det här avsnittet kommer vi att diskutera metoderna för API för kön. Kögränssnitt stöder olika operationer som infoga, ta bort, kika, etc. Vissa operationer ger ett undantag medan andra returnerar ett specifikt värde när metoden lyckas eller misslyckas.
Observera att det inte finns några specifika ändringar i kösamlingen i Java 8. Nedanstående metoder finns också i senare versioner av Java som Java 9, etc.
Tabellen nedan sammanfattar alla dessa metoder.
| Metod | Metodprototyp | Beskrivning |
|---|---|---|
| storlek | int storlek () | Returnerar storleken eller antalet element i kön. |
| Lägg till | boolesk tillsats (E e) | Lägger till element e i kön i slutet (svansen) av kön utan att bryta mot begränsningarna för kapaciteten. Returnerar true om framgång eller IllegalStateException om kapaciteten är slut. |
| titt | E titt () | Returnerar huvudet (främre delen) av kön utan att ta bort det. |
| element | E-element () | Utför samma operation som peek () -metoden. Kastar NoSuchElementException när kön är tom. |
| ta bort | E ta bort () | Tar bort köhuvudet och returnerar det. Kastar NoSuchElementException om kön är tom. |
| opinionsundersökning | E-undersökning () | Tar bort köhuvudet och returnerar det. Om kön är tom returnerar den null. |
| Erbjudande | booleskt erbjudande (E e) | Sätt in det nya elementet e i kön utan att bryta mot kapacitetsbegränsningar. |
Iterera köelementen
Vi kan korsa köelementen antingen med hjälp av forEach-slingan eller med en iterator. Programmet nedan implementerar båda metoderna för att korsa kön.
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öelementen genom iterator:
Värde-0 Värde-1 Värde-2 Värde-3
Köelementen som använder för loop:
Värde-0 Värde-1 Värde-2 Värde-3
Implementering av Java-kö
Programmet nedan visar metoderna som vi diskuterade ovan.
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:
Element i kö: (10, 20, 30, 40, 50)
Element borttaget från kön: 10
Köchef: 20
Omröstning (): Återvänt köhuvud: 20
kika (): Chef för kön: 30
Slutkön: (30, 40, 50)
Java Queue Array Implementation
Köimplementering är inte lika enkel som en stackimplementering. Först och främst innehåller kön två pekare, bak och fram. Olika operationer görs också i två olika ändar.
För att implementera kö med Arrays, förklarar vi först en matris som innehåller n antal köelement.
Sedan definierar vi följande åtgärder som ska utföras i den här kön.
# 1) Enqueue: En åtgärd för att infoga ett element i kön är Enqueue (funktionskönEnqueue i programmet). För att infoga ett element i bakänden måste vi först kontrollera om kön är full. Om den är full kan vi inte infoga elementet. Om bak # 2) Dequeue: Åtgärden för att radera ett element från kön är Dequeue (funktionsköDequeue i programmet). Först kontrollerar vi om kön är tom. För att dequeue-funktionen ska fungera måste det finnas minst ett element i kön. # 3) Fram: Den här metoden returnerar främre delen av kön. # 4) Display: Denna metod korsar kön och visar elementen i kön. Följande Java-program visar Array-implementeringen av kö. Produktion: Första kö: Eftersom vi har implementerat ködatastrukturen med hjälp av Arrays i ovanstående program kan vi också implementera kön med hjälp av länkad lista. Vi kommer att implementera samma metoder enqueue, dequeue, front och display i detta program. Skillnaden är att vi kommer att använda datastrukturen för den länkade listan istället för Array. Nedanstående program demonstrerar länkad implementering av kö i Java. Produktion: Element 6 läggs till i kön BlockingQueue är ett gränssnitt som läggs till i Java 1.5 och är en del av java.util.concurrent paket. Detta gränssnitt introducerar blockering om BlockingQueue är full eller tom. Således när en tråd kommer in i kön och försöker infoga (enqueue) element i en kö som redan är full blockeras tills en annan tråd skapar ett mellanslag i kön (kanske genom avkörningsoperation eller rensningskö). På samma sätt blockeras operationen i fallet med dequeuing om kön är tom tills elementet blir tillgängligt för dequeue-operationen. BlockingQueue-metoderna använder någon form av samtidighetskontroll som interna lås och är atomära. BlockingQueue är en samtidig kö som hanterar köoperationerna samtidigt. BlockingQueue visas nedan: Observera att BlockingQueue inte accepterar nollvärden. Ett försök att infoga ett nullvärde i kön resulterar i NullPointerException. Några av BlockingQueue-implementeringarna i Java är LinkedBlockingQueue, PriorityBlockingQueue, ArrayBlockingQueue och SynchonousQueue. Alla dessa implementeringar är trådsäkra. BlockingQueues är av två typer: I den avgränsade kön överförs köns kapacitet till konstruktören för kön. Köförklaringen är som följer: BlockingQueue blockingQueue = ny LinkedBlockingDeque (5); I den obegränsade kön ställer vi inte in kapacitet för kön uttryckligen och den kan växa i storlek. Kapaciteten är inställd på Integer.MAX_VALUE. Deklarationen om den obegränsade köen är som följer: BlockingQueue blockingQueue = ny LinkedBlockingDeque (); BlockingQueue-gränssnittet används i första hand för producent-konsumenttyper av problem där producenten producerar resurserna och konsumenten förbrukar resurserna. F # 1) Vad är en kö i Java? Svar: Kö i Java är en linjär ordnad datastruktur som följer FIFO (First In, First Out) -beställning av element. Detta innebär att det element som infogas först i kön blir det första elementet som tas bort. I Java implementeras kön som ett gränssnitt som ärver samlingsgränssnittet. F # 2) Är en kötrådssäker Java? Svar: Inte alla köer är trådsäkra men BlockingQueues i Java är trådsäkra. F # 3) Vilket är snabbare - Stack eller kö? Svar: Stapeln är snabbare. I stapeln bearbetas elementen endast från ena änden, varför ingen förskjutning krävs. Men i kön måste elementen flyttas och justeras eftersom det finns två olika pekare för att infoga och ta bort element. F # 4) Vilka är typerna av kö? Svar: Köerna är av följande typer: F # 5) Varför används köen? Svar: Kodatastrukturen används för synkroniseringsändamål. Kön används också för schemaläggning av disk och CPU. I den här handledningen har vi diskuterat de enkla köerna tillsammans med deras detaljer som deklarationer, initialiseringsimplementering och metoder. Vi lärde oss också om Array- och LinkedList-implementeringen av Queue i Java. I våra kommande handledning kommer vi att diskutera fler typer av köer i detalj. => Kontrollera ALLA Java-handledning här. 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ön är tom
Kö efter Enqueue-operation:
10 = 30 = 50 = 70 =
Köns främre element: 10
Kön är full
10 = 30 = 50 = 70 =
Kö efter två dequeue-operationer: 50 = 70 =
Köns främre element: 50
Implementering av Java-kö-länkad lista
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 har lagts till i kön
Kön framför: 6 Kön bak: 3
Element 12 läggs till i kön
Element 24 har lagts till i kön
Element 6 tas bort från kön
Element 3 har tagits bort från kön
Element 9 har lagts till i kön
Kön framför: 12 Kön bak: 9
BlockingQueue i Java
BlockingQueue-typer
Avgränsad kö
Obegränsad kö
Vanliga frågor
Slutsats
Rekommenderad läsning