Kø-grænsefladen er til stede i java.util pakke og udvider Samling grænseflade bruges til at holde de elementer, der skal behandles, i FIFO (First In First Out) rækkefølge. Det er en ordnet liste over objekter med dens brug begrænset til at indsætte elementer i slutningen af listen og slette elementer fra starten af listen, (dvs.), den følger FIFO eller First-In-First-Out-princippet.
Som en grænseflade skal køen have en konkret klasse til deklarationen, og de mest almindelige klasser er Prioritetskø og LinkedList i Java. Bemærk, at ingen af disse implementeringer er trådsikre. Prioritetsblokeringskø er en alternativ implementering, hvis den trådsikre implementering er nødvendig.
Erklæring: Køgrænsefladen erklæres som:
public interface Queue extends Collection>
Oprettelse af køobjekter: Siden Kø er en interface , kan der ikke oprettes objekter af typekøen. Vi har altid brug for en klasse, som udvider denne liste for at kunne oprette et objekt. Og også efter introduktionen af Generiske lægemidler i Java 1.5 er det muligt at begrænse den type objekt, der kan gemmes i køen. Denne typesikre kø kan defineres som:
// Obj is the type of the object to be stored in Queue Queue queue = new PriorityQueue ();>
I Java er Queue-grænsefladen en undertype af Collection-grænsefladen og repræsenterer en samling af elementer i en bestemt rækkefølge. Det følger først ind, først ud (FIFO) princippet, hvilket betyder, at elementerne hentes i den rækkefølge, de blev tilføjet til køen.
Køgrænsefladen giver flere metoder til at tilføje, fjerne og inspicere elementer i køen. Her er nogle af de mest brugte metoder:
add(element): Tilføjer et element bagerst i køen. Hvis køen er fuld, giver det en undtagelse.
tilbud(element): Tilføjer et element bagerst i køen. Hvis køen er fuld, returnerer den falsk.
remove(): Fjerner og returnerer elementet foran i køen. Hvis køen er tom, giver den en undtagelse.
poll(): Fjerner og returnerer elementet foran i køen. Hvis køen er tom, returnerer den null.
element(): Returnerer elementet foran i køen uden at fjerne det. Hvis køen er tom, giver den en undtagelse.
peek(): Returnerer elementet foran i køen uden at fjerne det. Hvis køen er tom, returnerer den null.
Køgrænsefladen er implementeret af flere klasser i Java, inklusive LinkedList, ArrayDeque og PriorityQueue. Hver af disse klasser giver forskellige implementeringer af køgrænsefladen med forskellige ydeevnekarakteristika og funktioner.
Overordnet set er Queue-grænsefladen et nyttigt værktøj til at administrere samlinger af elementer i en bestemt rækkefølge, og det er meget udbredt i mange forskellige applikationer og industrier.
maskinskrift for hver
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);> >}> }> |
>
>Produktion
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);> >}> }> |
>
>Produktion
Elements of queue [0, 1, 2, 3, 4] removed element-0 [1, 2, 3, 4] head of queue-1 Size of queue-4>
Operationer på køgrænseflade
Lad os se, hvordan du udfører et par ofte brugte operationer i køen ved hjælp af Prioritetskøklasse .
1. Tilføjelse af elementer: For at tilføje et element i en kø, kan vi bruge add() metode . Indsættelsesrækkefølgen bibeholdes ikke i PriorityQueue. Elementerne gemmes baseret på prioritetsrækkefølgen, som er stigende som standard.
Eksempel
Java
javascript advarselsboks
// 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);> >}> }> |
>
>
tiger løve forskelProduktion
[For, Geeks, Geeks]>
2. Fjernelse af elementer: For at fjerne et element fra en kø, kan vi bruge remove() metode. Hvis der er flere sådanne objekter, fjernes den første forekomst af objektet. Bortset fra det bruges poll() metoden også til at fjerne hovedet 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);> >}> }> |
>
>Produktion
Initial Queue [For, Geeks, Geeks] After Remove [For, Geeks] Poll Method For Final Queue [Geeks]>
3. Gentagelse af køen: Der er flere måder at gentage gennem køen. Den mest berømte måde er at konvertere køen til arrayet og krydse ved hjælp af for-løkken. Køen har dog også en indbygget iterator, som kan bruges til at iterere gennem 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() +>' '>);> >}> >}> }> |
>
>Produktion
For Geeks Geeks>
Karakteristika for en kø: Følgende er karakteristika for køen:
- Køen bruges til at indsætte elementer i slutningen af køen og fjernes fra begyndelsen af køen. Det følger FIFO-konceptet.
- Java Queue understøtter alle metoder til samlingsgrænseflade, inklusive indsættelse, sletning osv.
- LinkedList , ArrayBlockingQueue og Prioritetskø er de mest anvendte implementeringer.
- Hvis en nul-handling udføres på BlockingQueues, kastes NullPointerException.
- De køer, der er tilgængelige i java.util-pakken, er ubundne køer.
- De køer, der er tilgængelige i java.util.concurrent-pakken, er de afgrænsede køer.
- Alle køer undtagen Deques understøtter indsættelse og fjernelse ved henholdsvis hale og hoved af køen. Deques understøtter indsættelse og fjernelse af element i begge ender.
Klasser, der implementerer køgrænsefladen:
1. Prioritetskø: PriorityQueue-klassen, som er implementeret i samlingsrammen, giver os en måde at behandle objekterne på baseret på prioriteten. Det er kendt, at en kø følger First-In-First-Out-algoritmen, men nogle gange er det nødvendigt, at elementerne i køen behandles i henhold til prioriteten, det er her, PriorityQueue kommer i spil. Lad os se, hvordan du opretter et køobjekt ved hjælp af denne klasse.
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());> >}> }> |
>
>Produktion
10 10 15>
2. Linket liste: LinkedList er en klasse, der er implementeret i samlingsrammerne, som i sagens natur implementerer Eksempel
Java
amplitudemodulation
// 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());> >}> }> |
>
>Produktion
10 10 20>
3. Prioritetsblokeringskø: Det skal bemærkes, at både implementeringerne, PriorityQueue og LinkedList ikke er trådsikre. PriorityBlockingQueue er en alternativ implementering, hvis der er behov for trådsikker implementering. PriorityBlockingQueue er en ubegrænset blokeringskø, der bruger de samme bestillingsregler som klasse Prioritetskø og forsyninger, der blokerer for genfindingsoperationer.
Da det er ubegrænset, kan tilføjelse af elementer nogle gange mislykkes på grund af ressourceudmattelse, hvilket resulterer i OutOfMemoryError . Lad os se, hvordan du opretter et køobjekt ved hjælp af denne klasse.
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());> >}> }> |
>
>Produktion
10 10 15>
Metoder til køinterface
Køgrænsefladen arver alle de metoder, der findes i samlingsgrænseflade mens du implementerer følgende metoder:
| Metode | Beskrivelse |
|---|---|
| add(int indeks, element) | Denne metode bruges til at tilføje et element ved et bestemt indeks i køen. Når en enkelt parameter sendes, tilføjer den blot elementet i slutningen af køen. |
| addAll(int index, Collection collection) | Denne metode bruges til at tilføje alle elementerne i den givne samling til køen. Når en enkelt parameter sendes, tilføjer den alle elementerne i den givne samling i slutningen af køen. |
| størrelse() | Denne metode bruges til at returnere størrelsen af køen. |
| klar() | Denne metode bruges til at fjerne alle elementer i køen. Referencen for den oprettede kø er dog stadig gemt. |
| fjerne() | Denne metode bruges til at fjerne elementet fra forsiden af køen. |
| fjern (int indeks) | Denne metode fjerner et element fra det angivne indeks. Det flytter efterfølgende elementer (hvis nogen) til venstre og reducerer deres indeks med 1. |
| fjerne (element) | Denne metode bruges til at fjerne og returnere den første forekomst af det givne element i køen. |
| get (int indeks) | Denne metode returnerer elementer ved det angivne indeks. |
| sæt(int indeks, element) | Denne metode erstatter elementer ved et givet indeks med det nye element. Denne funktion returnerer det element, som lige blev erstattet af et nyt element. |
| indeksOf(element) | Denne metode returnerer den første forekomst af det givne element eller -1 hvis elementet ikke er til stede i køen. |
| lastIndexOf(element) | Denne metode returnerer den sidste forekomst af det givne element eller -1 hvis elementet ikke er til stede i køen. |
| er lig med (element) | Denne metode bruges til at sammenligne det givne elements lighed med elementerne i køen. |
| hashCode() | Denne metode bruges til at returnere hashkodeværdien for den givne kø. |
| er tom() | Denne metode bruges til at kontrollere, om køen er tom eller ej. Det returnerer sandt, hvis køen er tom, ellers falsk. |
| indeholder (element) | Denne metode bruges til at kontrollere, om køen indeholder det givne element eller ej. Det returnerer sandt, hvis køen indeholder elementet. |
| indeholder Alle (Samling samling) | Denne metode bruges til at kontrollere, om køen indeholder hele samlingen af elementer. |
| sorter (Komparator comp) | Denne metode bruges til at sortere elementerne i køen ud fra det givne komparator . |
| boolsk tilføjelse(objekt) | Denne metode bruges til at indsætte det angivne element i en kø og returnere sand ved succes. |
| boolesk tilbud (objekt) | Denne metode bruges til at indsætte det angivne element i køen. |
| Objektundersøgelse() | Denne metode bruges til at hente og fjerne hovedet i køen, eller returnerer null, hvis køen er tom. |
| Objektelement() | Denne metode bruges til at hente, men fjerner ikke, lederen af køen. |
| Objekt kig() | Denne metode bruges til at hente, men fjerner ikke, hovedet af denne kø eller returnerer null, hvis denne kø er tom. |
Fordele ved at bruge Queue-grænsefladen i Java:
Ordrebevaring : Køgrænsefladen giver mulighed for at gemme og hente elementer i en bestemt rækkefølge efter først-ind, først-ud-princippet (FIFO).
tostring metode
Fleksibilitet : Kø-grænsefladen er en undertype af Collection-grænsefladen, hvilket betyder, at den kan bruges med mange forskellige datastrukturer og algoritmer, afhængigt af applikationens krav.
Tråd – sikkerhed : Nogle implementeringer af Queue-grænsefladen, såsom java.util.concurrent.ConcurrentLinkedQueue-klassen, er trådsikre, hvilket betyder, at de kan tilgås af flere tråde samtidigt uden at forårsage konflikter.
Ydeevne : Kø-grænsefladen giver effektive implementeringer til tilføjelse, fjernelse og inspektion af elementer, hvilket gør det til et nyttigt værktøj til at administrere samlinger af elementer i ydeevnekritiske applikationer.
Ulemper ved at bruge Queue-grænsefladen i Java:
Begrænset funktionalitet: Kø-grænsefladen er designet specifikt til at administrere samlinger af elementer i en bestemt rækkefølge, hvilket betyder, at den muligvis ikke er egnet til mere komplekse datastrukturer eller algoritmer.
Størrelsesbegrænsninger: Nogle implementeringer af Queue-grænsefladen, såsom ArrayDeque-klassen, har en fast størrelse, hvilket betyder, at de ikke kan vokse ud over et vist antal elementer.
Hukommelsesbrug: Afhængigt af implementeringen kan Kø-grænsefladen kræve mere hukommelse end andre datastrukturer, især hvis den skal gemme yderligere information om rækkefølgen af elementerne.
Kompleksitet : Køgrænsefladen kan være svær at bruge og forstå for nybegyndere, især hvis de ikke er fortrolige med principperne for datastrukturer og algoritmer.