java queue queue methods
beste praksis for automatisering i programvaretesting
I denne veiledningen vil vi diskutere hva som er en kø i Java, hvordan du bruker den, Java køeksempel, Java kømetoder og køgrensesnittimplementering:
En kø er en lineær datastruktur eller en samling i Java som lagrer elementer i en FIFO (First In, First Out) -rekkefølge.
Køsamlingen har to ender, dvs. foran og bak. Elementene er lagt bak og fjernet fra fronten.
=> Besøk her for å se Java Training Series for alle.
Hva du vil lære:
Hva er en Java-kø?
En kødatastruktur er representert som vist nedenfor:
Som vist i diagrammet ovenfor, er en kø en struktur som har to punkter, dvs. start (foran) og slutt (bak). Elementer settes inn i køen i bakenden og fjernes fra køen foran.
I Java er kø et grensesnitt som er en del av pakken java.util. Køgrensesnittet utvider Java Collection-grensesnittet.
Den generelle definisjonen av køgrensesnittet er:
public interface Queue extends CollectionSiden køen er et grensesnitt, kan den ikke instantieres. Vi trenger noen konkrete klasser for å implementere funksjonaliteten til køgrensesnittet. To klasser implementerer køgrensesnittet, dvs. LinkedList og PriorityQueue.
Følgende er noen av de viktigste egenskapene til kødatastrukturen:
- Kø følger FIFO-bestillingen (First In, First Out). Dette betyr at elementet settes inn i køen på slutten og fjernes fra køen i begynnelsen.
- Java-køgrensesnittet gir alle metodene for Collection-grensesnitt som innsetting, sletting, etc.
- LinkedList og PriorityQueue er klassene som implementerer køgrensesnittet. ArrayBlockingQueue er enda en klasse som implementerer køgrensesnittet.
- Køene som er en del av java.util-pakken kan klassifiseres som ubegrensede køer mens de som er tilstede i java.util. Den samtidige pakken er avgrensede køer.
- Deque er en kø som støtter innsetting og sletting fra begge ender.
- Dekket er trådsikkert.
- BlockingQueues er trådsikre og brukes til å implementere produsent-forbrukerproblemer.
- BlockingQueues tillater ikke nullelementer. Et NullPointerException kastes hvis det blir forsøkt på en operasjon relatert til nullverdier.
Hvordan bruke en kø i Java?
For å bruke en kø i Java, må vi først importere køgrensesnittet som følger:
import java.util.queue; Eller
import java.util.*; Når dette er importert, kan vi opprette en kø som vist nedenfor:
Queue str_queue = new LinkedList (); Siden kø er et grensesnitt, bruker vi en LinkedList-klasse som implementerer køgrensesnittet for å opprette et køobjekt.
På samme måte kan vi opprette en kø med andre konkrete klasser.
Queue str_pqueue = new PriorityQueue (); Queue int_queue = new ArrayDeque (); Nå som køobjektet er opprettet, kan vi initialisere køobjektet ved å gi verdiene til det gjennom tilleggsmetoden som vist nedenfor.
str_queue.add(“one”); str_queue.add(“two”); str_queue.add(“three”);Java køeksempel
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); } }Produksjon:
Køinnholdet: (en, to, tre, fire)
Ovenstående eksempel viser erklæringen og initialiseringen av et køobjekt. Deretter skriver vi bare ut innholdet i køen.
Kømetoder i Java
I denne delen vil vi diskutere metodene for API for køen. Køgrensesnitt støtter forskjellige operasjoner som innsetting, sletting, titt, etc. Noen operasjoner gir et unntak mens noen returnerer en bestemt verdi når metoden lykkes eller mislykkes.
Merk at det ikke er noen spesifikke endringer i køsamlingen i Java 8. Metodene nedenfor er også tilgjengelige i senere versjoner av Java som Java 9, etc.
Tabellen nedenfor oppsummerer alle disse metodene.
| Metode | Metode Prototype | Beskrivelse |
|---|---|---|
| størrelse | int størrelse () | Returnerer størrelsen eller antall elementer i køen. |
| Legg til | boolsk tilsetning (E e) | Legger til element e i køen på slutten (halen) av køen uten å bryte begrensningene på kapasiteten. Returnerer sant hvis suksess eller IllegalStateException hvis kapasiteten er oppbrukt. |
| kikke | E titt () | Returnerer hodet (foran) i køen uten å fjerne det. |
| element | E-element () | Utfører samme operasjon som peek () -metoden. Kaster NoSuchElementException når køen er tom. |
| ta vekk | E fjerne () | Fjern hodet på køen og returnerer den. Kaster NoSuchElementException hvis køen er tom. |
| avstemming | E-avstemning () | Fjern hodet på køen og returnerer den. Hvis køen er tom, returnerer den null. |
| By på | boolsk tilbud (E e) | Sett inn det nye elementet e i køen uten å bryte kapasitetsbegrensningene. |
Iterere køelementene
Vi kan krysse køelementene enten ved hjelp av forEach-løkken eller ved hjelp av en iterator. Programmet nedenfor implementerer begge tilnærmingene til å krysse 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 + ' '); } } }Produksjon:
Køelementene gjennom iterator:
Verdi-0 Verdi-1 Verdi-2 Verdi-3
Køelementene som bruker for loop:
Verdi-0 Verdi-1 Verdi-2 Verdi-3
Implementering av Java-kø
Programmet nedenfor viser metodene vi diskuterte 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); } } Produksjon:
Elementer i kø: (10, 20, 30, 40, 50)
Element fjernet fra køen: 10
Køhode: 20
Avstemning (): Returnert køhode: 20
titt (): Leder av køen: 30
Endelig kø: (30, 40, 50)
Implementering av Java Queue Array
Køimplementering er ikke så grei som en stackimplementering. Først og fremst inneholder køen to pekere, bak og foran. Også forskjellige operasjoner gjøres i to forskjellige ender.
For å implementere kø ved hjelp av Arrays, erklærer vi først en matrise som vil inneholde n antall køelementer.
Deretter definerer vi følgende operasjoner som skal utføres i denne køen.
# 1) Enqueue: En operasjon for å sette inn et element i køen er Enqueue (funksjonskøEnqueue i programmet). For å sette inn et element i bakenden, må vi først sjekke om køen er full. Hvis den er full, kan vi ikke sette inn elementet. Hvis bak # 2) Dequeue: Operasjonen for å slette et element fra køen er Dequeue (funksjonskøDequeue i programmet). Først sjekker vi om køen er tom. For at dequeue-drift skal fungere, må det være minst ett element i køen. # 3) Front: Denne metoden returnerer forsiden av køen. # 4) Skjerm: Denne metoden krysser køen og viser elementene i køen. Følgende Java-program demonstrerer Array-implementeringen av Kø. Produksjon: Innledende kø: Ettersom vi har implementert kødatastrukturen ved hjelp av Arrays i programmet ovenfor, kan vi også implementere køen ved hjelp av koblet liste. Vi vil implementere de samme metodene enqueue, dequeue, front og display i dette programmet. Forskjellen er at vi vil bruke datastrukturen for koblet liste i stedet for Array. Programmet nedenfor viser implementeringen av koblet liste over kø i Java. Produksjon: Element 6 lagt til køen BlockingQueue er et grensesnitt lagt til i Java 1.5 og er en del av java.util.concurrent pakke. Dette grensesnittet introduserer blokkering i tilfelle BlockingQueue er full eller tom. Når en tråd får tilgang til køen og prøver å sette inn (enqueue) -elementer i en kø som allerede er full, blir det blokkert til en annen tråd oppretter et mellomrom i køen (kanskje ved avkjøring eller tømningskø). På samme måte, i tilfelle dequeuing, blokkeres operasjonen hvis køen er tom til elementet blir tilgjengelig for dequeue-operasjonen. BlockingQueue-metodene bruker en form for samtidighetskontroll som interne låser og er atomare. BlockingQueue er en samtidig kø som administrerer køoperasjonene samtidig. BlockingQueue vises nedenfor: Merk at BlockingQueue ikke godtar nullverdier. Et forsøk på å sette inn en nullverdi i køen resulterer i NullPointerException. Noen av BlockingQueue-implementeringene som tilbys i Java er LinkedBlockingQueue, PriorityBlockingQueue, ArrayBlockingQueue og SynchonousQueue. Alle disse implementeringene er trådsikre. BlockingQueues er av to typer: I den avgrensede køen overføres kapasiteten til køen til konstruktøren av køen. Køerklæringen er som følger: BlockingQueue blockingQueue = ny LinkedBlockingDeque (5); I den ubegrensede køen angir vi ikke køens kapasitet eksplisitt, og den kan vokse i størrelse. Kapasiteten er satt til Integer.MAX_VALUE. Erklæringen om den ubegrensede køen er som følger: BlockingQueue blockingQueue = ny LinkedBlockingDeque (); BlockingQueue-grensesnittet brukes primært til produsent-forbruker-typer problemer der produsenten produserer ressursene og forbrukeren bruker ressursene. Q # 1) Hva er en kø i Java? Svar: Kø i Java er en lineær ordnet datastruktur som følger FIFO (First In, First Out) bestilling av elementer. Dette betyr at elementet som settes inn først i køen, vil være det første elementet som fjernes. I Java er køen implementert som et grensesnitt som arver Collection-grensesnittet. 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) Hva er raskere - stabel eller kø? Svar: Bunken er raskere. I stabel behandles elementene bare fra den ene enden, derfor er det ikke nødvendig å skifte. Men i køen må elementene forskyves og justeres ettersom det er to forskjellige pekere for å sette inn og slette elementer. Q # 4) Hva er typene av kø? Svar: Køene er av følgende typer: Q # 5) Hvorfor brukes køen? Svar: Kødatastrukturen brukes til synkroniseringsformål. Køen brukes også til planlegging av disk og CPU. I denne opplæringen har vi diskutert de enkle køene sammen med deres detaljer som erklæringer, implementering av initialisering og metoder. Vi lærte også om implementering av Array og LinkedList av Queue i Java. I våre kommende veiledninger vil vi diskutere flere typer køer i detalj. => Sjekk ALLE Java-opplæringsprogrammer her. 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ø etter Enqueue-drift:
10 = 30 = 50 = 70 =
Frontelement i køen: 10
Køen er full
10 = 30 = 50 = 70 =
Kø etter to dequeue-operasjoner: 50 = 70 =
Frontelement i køen: 50
Implementering av Java-kø-koblet 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 lagt til køen
Forsiden av køen: 6 Bakre køen: 3
Element 12 lagt til køen
Element 24 lagt til køen
Element 6 fjernet fra køen
Element 3 fjernet fra køen
Element 9 lagt til køen
Foran i køen: 12 Bak i køen: 9
BlockingQueue i Java
BlockingQueue-typer
Avgrenset kø
Ubundet kø
ofte stilte spørsmål
Konklusjon
Anbefalt lesing