Kø-grensesnittet er til stede i java.util pakke og utvider Samlingsgrensesnitt brukes til å holde elementene som skal behandles i FIFO (First In First Out) rekkefølge. Det er en ordnet liste over objekter med dens bruk begrenset til å sette inn elementer på slutten av listen og slette elementer fra starten av listen, (dvs.), den følger FIFO eller først-inn-først-ut-prinsippet.
Som et grensesnitt trenger køen en konkret klasse for erklæringen, og de vanligste klassene er Prioritetskø og LinkedList i Java. Merk at ingen av disse implementeringene er trådsikre. Prioritetsblokkeringskø er en alternativ implementering hvis den trådsikre implementeringen er nødvendig.
Erklæring: Køgrensesnittet er deklarert som:
public interface Queue extends Collection>
Opprette køobjekter: Siden Kø er en grensesnitt , objekter kan ikke opprettes av typekøen. Vi trenger alltid en klasse som utvider denne listen for å lage et objekt. Og også, etter introduksjonen av Generiske legemidler i Java 1.5 er det mulig å begrense typen objekt som kan lagres i køen. Denne typesikre køen kan defineres som:
// Obj is the type of the object to be stored in Queue Queue queue = new PriorityQueue ();>
I Java er Queue-grensesnittet en undertype av Collection-grensesnittet og representerer en samling av elementer i en bestemt rekkefølge. Den følger først inn, først ut (FIFO) prinsippet, som betyr at elementene hentes i den rekkefølgen de ble lagt til i køen.
Kø-grensesnittet gir flere metoder for å legge til, fjerne og inspisere elementer i køen. Her er noen av de mest brukte metodene:
add(element): Legger til et element bak i køen. Hvis køen er full, gir den et unntak.
offer(element): Legger til et element bak i køen. Hvis køen er full, returnerer den falsk.
remove(): Fjerner og returnerer elementet foran i køen. Hvis køen er tom, gir den et unntak.
poll(): Fjerner og returnerer elementet foran i køen. Hvis køen er tom, returnerer den null.
element(): Returnerer elementet foran i køen uten å fjerne det. Hvis køen er tom, gir den et unntak.
peek(): Returnerer elementet foran i køen uten å fjerne det. Hvis køen er tom, returnerer den null.
Kø-grensesnittet er implementert av flere klasser i Java, inkludert LinkedList, ArrayDeque og PriorityQueue. Hver av disse klassene gir forskjellige implementeringer av køgrensesnittet, med forskjellige ytelsesegenskaper og funksjoner.
Samlet sett er Queue-grensesnittet et nyttig verktøy for å administrere samlinger av elementer i en bestemt rekkefølge, og er mye brukt i mange forskjellige applikasjoner og bransjer.
mia khalifa alder
Eksempel:
Java
import> java.util.LinkedList;> import> java.util.Queue;> public> class> QueueExample {> >public> static> void> main(String[] args) {> >Queue queue =>new> LinkedList();> >// add elements to the queue> >queue.add(>'apple'>);> >queue.add(>'banana'>);> >queue.add(>'cherry'>);> >// print the queue> >System.out.println(>'Queue: '> + queue);> >// remove the element at the front of the queue> >String front = queue.remove();> >System.out.println(>'Removed element: '> + front);> >// print the updated queue> >System.out.println(>'Queue after removal: '> + queue);> >// add another element to the queue> >queue.add(>'date'>);> >// peek at the element at the front of the queue> >String peeked = queue.peek();> >System.out.println(>'Peeked element: '> + peeked);> >// print the updated queue> >System.out.println(>'Queue after peek: '> + queue);> >}> }> |
>
>Produksjon
Queue: [apple, banana, cherry] Removed element: apple Queue after removal: [banana, cherry] Peeked element: banana Queue after peek: [banana, cherry, date]>
Eksempel: Kø
Java
// Java program to demonstrate a Queue> import> java.util.LinkedList;> import> java.util.Queue;> public> class> QueueExample {> >public> static> void> main(String[] args)> >{> >Queue q> >=>new> LinkedList();> >// Adds elements {0, 1, 2, 3, 4} to> >// the queue> >for> (>int> i =>0>; i <>5>; i++)> >q.add(i);> >// Display contents of the queue.> >System.out.println(>'Elements of queue '> >+ q);> >// To remove the head of queue.> >int> removedele = q.remove();> >System.out.println(>'removed element-'> >+ removedele);> >System.out.println(q);> >// To view the head of queue> >int> head = q.peek();> >System.out.println(>'head of queue-'> >+ head);> >// Rest all methods of collection> >// interface like size and contains> >// can be used with this> >// implementation.> >int> size = q.size();> >System.out.println(>'Size of queue-'> >+ size);> >}> }> |
>
>Produksjon
Elements of queue [0, 1, 2, 3, 4] removed element-0 [1, 2, 3, 4] head of queue-1 Size of queue-4>
Operasjoner på køgrensesnitt
La oss se hvordan du utfører noen få ofte brukte operasjoner i køen ved å bruke Prioritert køklasse .
1. Legge til elementer: For å legge til et element i en kø, kan vi bruke add() metode . Innsettingsrekkefølgen beholdes ikke i PriorityQueue. Elementene lagres basert på prioritetsrekkefølgen som er stigende som standard.
Eksempel
Java
java dynamisk array
// Java program to add elements> // to a Queue> import> java.util.*;> public> class> GFG {> >public> static> void> main(String args[])> >{> >Queue pq =>new> PriorityQueue();> >pq.add(>'Geeks'>);> >pq.add(>'For'>);> >pq.add(>'Geeks'>);> >System.out.println(pq);> >}> }> |
>
>
program i javaProduksjon
[For, Geeks, Geeks]>
2. Fjerning av elementer: For å fjerne et element fra en kø, kan vi bruke remove() metoden. Hvis det er flere slike objekter, fjernes den første forekomsten av objektet. Bortsett fra det, brukes også poll()-metoden for å fjerne hodet og returnere det.
Eksempel
Java
// Java program to remove elements> // from a Queue> import> java.util.*;> public> class> GFG {> >public> static> void> main(String args[])> >{> >Queue pq =>new> PriorityQueue();> >pq.add(>'Geeks'>);> >pq.add(>'For'>);> >pq.add(>'Geeks'>);> >System.out.println(>'Initial Queue '> + pq);> >pq.remove(>'Geeks'>);> >System.out.println(>'After Remove '> + pq);> >System.out.println(>'Poll Method '> + pq.poll());> >System.out.println(>'Final Queue '> + pq);> >}> }> |
>
>Produksjon
Initial Queue [For, Geeks, Geeks] After Remove [For, Geeks] Poll Method For Final Queue [Geeks]>
3. Gjenta køen: Det er flere måter å iterere gjennom køen. Den mest kjente måten er å konvertere køen til matrisen og krysse ved å bruke for-løkken. Køen har imidlertid også en innebygd iterator som kan brukes til å iterere gjennom køen.
Eksempel
Java
// Java program to iterate elements> // to a Queue> import> java.util.*;> public> class> GFG {> >public> static> void> main(String args[])> >{> >Queue pq =>new> PriorityQueue();> >pq.add(>'Geeks'>);> >pq.add(>'For'>);> >pq.add(>'Geeks'>);> >Iterator iterator = pq.iterator();> >while> (iterator.hasNext()) {> >System.out.print(iterator.next() +>' '>);> >}> >}> }> |
>
>Produksjon
For Geeks Geeks>
Kjennetegn ved en kø: Følgende er egenskapene til køen:
- Køen brukes til å sette inn elementer på slutten av køen og fjernes fra begynnelsen av køen. Den følger FIFO-konseptet.
- Java Queue støtter alle metoder for samlingsgrensesnitt, inkludert innsetting, sletting, etc.
- LinkedList , ArrayBlockingQueue og Prioritetskø er de mest brukte implementeringene.
- Hvis en null-operasjon utføres på BlockingQueues, kastes NullPointerException.
- Køene som er tilgjengelige i java.util-pakken er ubundne køer.
- Køene som er tilgjengelige i java.util.concurrent-pakken er de begrensede køene.
- Alle køer unntatt Deques støtter innsetting og fjerning ved hhv. bakenden og toppen av køen. Deques støtter innsetting og fjerning av element i begge ender.
Klasser som implementerer køgrensesnittet:
1. Prioritetskø: PriorityQueue-klassen som er implementert i samlingsrammeverket gir oss en måte å behandle objektene på basert på prioriteringen. Det er kjent at en kø følger First-In-First-Out-algoritmen, men noen ganger må elementene i køen behandles i henhold til prioritet, det er da PriorityQueue kommer inn i bildet. La oss se hvordan du oppretter et køobjekt ved å bruke denne klassen.
Eksempel
Java
// Java program to demonstrate the> // creation of queue object using the> // PriorityQueue class> import> java.util.*;> class> GfG {> >public> static> void> main(String args[])> >{> >// Creating empty priority queue> >Queue pQueue> >=>new> PriorityQueue();> >// Adding items to the pQueue> >// using add()> >pQueue.add(>10>);> >pQueue.add(>20>);> >pQueue.add(>15>);> >// Printing the top element of> >// the PriorityQueue> >System.out.println(pQueue.peek());> >// Printing the top element and removing it> >// from the PriorityQueue container> >System.out.println(pQueue.poll());> >// Printing the top element again> >System.out.println(pQueue.peek());> >}> }> |
>
>Produksjon
10 10 15>
2. Koblet liste: LinkedList er en klasse som er implementert i samlingsrammeverket som iboende implementerer Eksempel
Java
zip-kommando i linux
// Java program to demonstrate the> // creation of queue object using the> // LinkedList class> import> java.util.*;> class> GfG {> >public> static> void> main(String args[])> >{> >// Creating empty LinkedList> >Queue ll> >=>new> LinkedList();> >// Adding items to the ll> >// using add()> >ll.add(>10>);> >ll.add(>20>);> >ll.add(>15>);> >// Printing the top element of> >// the LinkedList> >System.out.println(ll.peek());> >// Printing the top element and removing it> >// from the LinkedList container> >System.out.println(ll.poll());> >// Printing the top element again> >System.out.println(ll.peek());> >}> }> |
>
>Produksjon
10 10 20>
3. Prioritetsblokkeringskø: Det skal bemerkes at både implementeringene, PriorityQueue og LinkedList ikke er trådsikre. PriorityBlockingQueue er en alternativ implementering hvis trådsikker implementering er nødvendig. PriorityBlockingQueue er en ubegrenset blokkeringskø som bruker de samme bestillingsreglene som klasse Prioritetskø og rekvisita som blokkerer gjenfinningsoperasjoner.
Siden det er ubegrenset, kan det noen ganger mislykkes å legge til elementer på grunn av ressursbruk som resulterer i OutOfMemoryError . La oss se hvordan du oppretter et køobjekt ved å bruke denne klassen.
Eksempel
Java
// Java program to demonstrate the> // creation of queue object using the> // PriorityBlockingQueue class> import> java.util.concurrent.PriorityBlockingQueue;> import> java.util.*;> class> GfG {> >public> static> void> main(String args[])> >{> >// Creating empty priority> >// blocking queue> >Queue pbq> >=>new> PriorityBlockingQueue();> >// Adding items to the pbq> >// using add()> >pbq.add(>10>);> >pbq.add(>20>);> >pbq.add(>15>);> >// Printing the top element of> >// the PriorityBlockingQueue> >System.out.println(pbq.peek());> >// Printing the top element and> >// removing it from the> >// PriorityBlockingQueue> >System.out.println(pbq.poll());> >// Printing the top element again> >System.out.println(pbq.peek());> >}> }> |
>
>Produksjon
10 10 15>
Metoder for køgrensesnitt
Køgrensesnittet arver alle metodene som finnes i samlingsgrensesnitt mens du implementerer følgende metoder:
| Metode | Beskrivelse |
|---|---|
| add(int indeks, element) | Denne metoden brukes til å legge til et element ved en bestemt indeks i køen. Når en enkelt parameter sendes, legger den ganske enkelt til elementet på slutten av køen. |
| addAll(int-indeks, samlingssamling) | Denne metoden brukes til å legge til alle elementene i den gitte samlingen i køen. Når en enkelt parameter sendes, legger den til alle elementene i den gitte samlingen på slutten av køen. |
| størrelse() | Denne metoden brukes til å returnere størrelsen på køen. |
| klar() | Denne metoden brukes til å fjerne alle elementene i køen. Referansen til den opprettede køen er imidlertid fortsatt lagret. |
| fjerne() | Denne metoden brukes til å fjerne elementet fra forsiden av køen. |
| remove(int index) | Denne metoden fjerner et element fra den angitte indeksen. Den flytter påfølgende elementer (hvis noen) til venstre og reduserer indeksene deres med 1. |
| fjerne (element) | Denne metoden brukes til å fjerne og returnere den første forekomsten av det gitte elementet i køen. |
| get (int indeks) | Denne metoden returnerer elementer ved den angitte indeksen. |
| sett(int indeks, element) | Denne metoden erstatter elementer ved en gitt indeks med det nye elementet. Denne funksjonen returnerer elementet som nettopp ble erstattet av et nytt element. |
| indeksOf(element) | Denne metoden returnerer den første forekomsten av det gitte elementet eller -1 hvis elementet ikke er tilstede i køen. |
| lastIndexOf(element) | Denne metoden returnerer siste forekomst av det gitte elementet eller -1 hvis elementet ikke er tilstede i køen. |
| lik(element) | Denne metoden brukes til å sammenligne likheten til det gitte elementet med elementene i køen. |
| hashkode() | Denne metoden brukes til å returnere hashkodeverdien til den gitte køen. |
| er tom() | Denne metoden brukes til å sjekke om køen er tom eller ikke. Den returnerer true hvis køen er tom, ellers falsk. |
| inneholder(element) | Denne metoden brukes til å sjekke om køen inneholder det gitte elementet eller ikke. Den returnerer sann hvis køen inneholder elementet. |
| containsAll (samlingssamling) | Denne metoden brukes til å sjekke om køen inneholder all samlingen av elementer. |
| sorter (sammenligningskomp) | Denne metoden brukes til å sortere elementene i køen på grunnlag av det gitte komparator . |
| boolsk add(objekt) | Denne metoden brukes til å sette inn det angitte elementet i en kø og returnere sant ved suksess. |
| boolsk tilbud (objekt) | Denne metoden brukes til å sette inn det angitte elementet i køen. |
| Objektundersøkelse() | Denne metoden brukes til å hente og fjerne hodet på køen, eller returnerer null hvis køen er tom. |
| Objektelement() | Denne metoden brukes til å hente, men fjerner ikke, lederen av køen. |
| Objekt kikk() | Denne metoden brukes til å hente, men fjerner ikke hodet til denne køen, eller returnerer null hvis denne køen er tom. |
Fordeler med å bruke Queue-grensesnittet i Java:
Ordrebevaring : Kø-grensesnittet gir en måte å lagre og hente elementer i en bestemt rekkefølge, etter først inn, først ut (FIFO)-prinsippet.
tostring-metoden
Fleksibilitet : Kø-grensesnittet er en undertype av Collection-grensesnittet, noe som betyr at det kan brukes med mange forskjellige datastrukturer og algoritmer, avhengig av kravene til applikasjonen.
Tråd – sikkerhet : Noen implementeringer av Queue-grensesnittet, som java.util.concurrent.ConcurrentLinkedQueue-klassen, er trådsikre, noe som betyr at de kan nås av flere tråder samtidig uten å forårsake konflikter.
Opptreden : Kø-grensesnittet gir effektive implementeringer for å legge til, fjerne og inspisere elementer, noe som gjør det til et nyttig verktøy for å administrere samlinger av elementer i ytelseskritiske applikasjoner.
Ulemper ved å bruke Queue-grensesnittet i Java:
Begrenset funksjonalitet: Kø-grensesnittet er designet spesielt for å administrere samlinger av elementer i en bestemt rekkefølge, noe som betyr at det kanskje ikke er egnet for mer komplekse datastrukturer eller algoritmer.
Størrelsesbegrensninger: Noen implementeringer av Queue-grensesnittet, for eksempel ArrayDeque-klassen, har en fast størrelse, noe som betyr at de ikke kan vokse utover et visst antall elementer.
Minnebruk: Avhengig av implementeringen kan Queue-grensesnittet kreve mer minne enn andre datastrukturer, spesielt hvis det trenger å lagre tilleggsinformasjon om rekkefølgen på elementene.
Kompleksitet : Kø-grensesnittet kan være vanskelig å bruke og forstå for nybegynnere programmerere, spesielt hvis de ikke er kjent med prinsippene for datastrukturer og algoritmer.