Kögränssnittet finns i java.util paketera och förlänger Samlingsgränssnitt används för att hålla elementen som ska bearbetas i ordning FIFO (First In First Out). Det är en ordnad lista över objekt med dess användning begränsad till att infoga element i slutet av listan och ta bort element från början av listan, (dvs.), den följer FIFO eller först-in-först-ut-principen.
Som ett gränssnitt behöver kön en konkret klass för deklarationen och de vanligaste klasserna är Prioritetskö och Länkad lista i Java. Observera att ingen av dessa implementeringar är trådsäkra. PriorityBlockingQueue är en alternativ implementering om den trådsäkra implementeringen behövs.
Deklaration: Kögränssnittet deklareras som:
public interface Queue extends Collection>
Skapa köobjekt: Eftersom Kö är en gränssnitt , objekt kan inte skapas av typkön. Vi behöver alltid en klass som utökar denna lista för att skapa ett objekt. Och även efter införandet av Generika i Java 1.5 är det möjligt att begränsa vilken typ av objekt som kan lagras i kön. Denna typsäkra kö kan definieras som:
// Obj is the type of the object to be stored in Queue Queue queue = new PriorityQueue ();>
I Java är kögränssnittet en undertyp av samlingsgränssnittet och representerar en samling element i en specifik ordning. Den följer först-in-först-ut-principen (FIFO), vilket innebär att elementen hämtas i den ordning som de lades till i kön.
Kögränssnittet tillhandahåller flera metoder för att lägga till, ta bort och inspektera element i kön. Här är några av de mest använda metoderna:
add(element): Lägger till ett element längst bak i kön. Om kön är full ger den ett undantag.
offer(element): Lägger till ett element längst bak i kön. Om kön är full, returnerar den falskt.
remove(): Tar bort och returnerar elementet längst fram i kön. Om kön är tom ger den ett undantag.
poll(): Tar bort och returnerar elementet längst fram i kön. Om kön är tom, returnerar den null.
element(): Returnerar elementet längst fram i kön utan att ta bort det. Om kön är tom ger den ett undantag.
peek(): Returnerar elementet längst fram i kön utan att ta bort det. Om kön är tom, returnerar den null.
Queue-gränssnittet implementeras av flera klasser i Java, inklusive LinkedList, ArrayDeque och PriorityQueue. Var och en av dessa klasser tillhandahåller olika implementeringar av kögränssnittet, med olika prestandaegenskaper och funktioner.
Sammantaget är Queue-gränssnittet ett användbart verktyg för att hantera samlingar av element i en specifik ordning, och används ofta i många olika applikationer och branscher.
Exempel:
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);> >}> }> |
>
array av struktur i c-språk
>Produktion
Queue: [apple, banana, cherry] Removed element: apple Queue after removal: [banana, cherry] Peeked element: banana Queue after peek: [banana, cherry, date]>
Exempel: 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änssnitt
Låt oss se hur du utför några ofta använda operationer i kön med hjälp av Prioriterad köklass .
1. Lägga till element: För att lägga till ett element i en kö kan vi använda add() metod . Insättningsordningen behålls inte i PriorityQueue. Elementen lagras baserat på prioritetsordningen som är stigande som standard.
Exempel
Java
// 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);> >}> }> |
>
>Produktion
[For, Geeks, Geeks]>
2. Ta bort element: För att ta bort ett element från en kö kan vi använda remove() metod. Om det finns flera sådana objekt tas den första förekomsten av objektet bort. Bortsett från det används poll() metoden också för att ta bort huvudet och returnera det.
Exempel
Java
supw
// 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. Iterera kön: Det finns flera sätt att iterera genom kön. Det mest kända sättet är att konvertera kön till arrayen och korsa med for-loopen. Men kön har också en inbyggd iterator som kan användas för att iterera genom kön.
Exempel
Java
all caps kommandot excel
// 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>
Egenskaper för en kö: Följande är egenskaperna hos kön:
- Kön används för att infoga element i slutet av kön och tar bort från början av kön. Det följer FIFO-konceptet.
- Java Queue stöder alla metoder för samlingsgränssnitt inklusive infogning, radering, etc.
- Länkad lista , ArrayBlockingQueue och Prioritetskö är de mest använda implementeringarna.
- Om någon nolloperation utförs på BlockingQueues, kastas NullPointerException.
- Köerna som är tillgängliga i paketet java.util är obegränsade köer.
- Köerna som är tillgängliga i paketet java.util.concurrent är de begränsade köerna.
- Alla köer utom Deques stöder insättning och borttagning vid slutet respektive huvudet av kön. Deques stödjer insättning och borttagning av element i båda ändar.
Klasser som implementerar kögränssnittet:
1. Prioritetskö: PriorityQueue-klassen som är implementerad i samlingsramverket ger oss ett sätt att bearbeta objekten baserat på prioriteten. Det är känt att en kö följer First-In-First-Out-algoritmen, men ibland behövs köns element för att bearbetas enligt prioritet, det är då PriorityQueue kommer till spel. Låt oss se hur man skapar ett köobjekt med den här klassen.
Exempel
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. Länkad lista: LinkedList är en klass som är implementerad i samlingsramverket som i sig implementerar Exempel
Java
// 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. PriorityBlockingQueue: Det bör noteras att både implementeringarna, PriorityQueue och LinkedList inte är trådsäkra. PriorityBlockingQueue är en alternativ implementering om trådsäker implementering behövs. PriorityBlockingQueue är en obegränsad blockeringskö som använder samma ordningsregler som klass Prioritetskö och förnödenheter som blockerar hämtning.
Eftersom det är obegränsat kan det ibland misslyckas att lägga till element på grund av resursutmattning som resulterar i OutOfMemoryError . Låt oss se hur man skapar ett köobjekt med den här klassen.
Exempel
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
java exempelkod
10 10 15>
Metoder för kögränssnitt
Kögränssnittet ärver alla metoder som finns i samlingsgränssnitt samtidigt som du implementerar följande metoder:
| Metod | Beskrivning |
|---|---|
| add(int index, element) | Denna metod används för att lägga till ett element vid ett visst index i kön. När en enskild parameter skickas lägger den helt enkelt till elementet i slutet av kön. |
| addAll(int index, Collection collection) | Denna metod används för att lägga till alla element i den givna samlingen till kön. När en enskild parameter skickas lägger den till alla element i den givna samlingen i slutet av kön. |
| storlek() | Denna metod används för att returnera storleken på kön. |
| klar() | Denna metod används för att ta bort alla element i kön. Referensen för den skapade kön lagras dock fortfarande. |
| avlägsna() | Denna metod används för att ta bort elementet från framsidan av kön. |
| remove(int index) | Denna metod tar bort ett element från det angivna indexet. Den flyttar efterföljande element (om några) till vänster och minskar deras index med 1. |
| remove(element) | Denna metod används för att ta bort och returnera den första förekomsten av det givna elementet i kön. |
| get(int index) | Denna metod returnerar element vid det angivna indexet. |
| set(int index, element) | Denna metod ersätter element vid ett givet index med det nya elementet. Denna funktion returnerar elementet som just ersattes av ett nytt element. |
| indexOf(element) | Denna metod returnerar den första förekomsten av det givna elementet eller -1 om elementet inte finns i kön. |
| lastIndexOf(element) | Denna metod returnerar den senaste förekomsten av det givna elementet eller -1 om elementet inte finns i kön. |
| lika med (element) | Denna metod används för att jämföra det givna elementets likhet med elementen i kön. |
| hash-kod() | Denna metod används för att returnera hashkodvärdet för den givna kön. |
| är tom() | Denna metod används för att kontrollera om kön är tom eller inte. Det returnerar sant om kön är tom, annars falskt. |
| innehåller(element) | Denna metod används för att kontrollera om kön innehåller det givna elementet eller inte. Det returnerar sant om kön innehåller elementet. |
| containsAll(samlingssamling) | Denna metod används för att kontrollera om kön innehåller all samling av element. |
| sort(Comparator comp) | Denna metod används för att sortera elementen i kön på basis av det givna komparator . |
| boolean add(objekt) | Denna metod används för att infoga det angivna elementet i en kö och returnera sant vid framgång. |
| booleskt erbjudande (objekt) | Denna metod används för att infoga det angivna elementet i kön. |
| Objektundersökning() | Denna metod används för att hämta och ta bort huvudet på kön, eller returnerar null om kön är tom. |
| Objektelement() | Denna metod används för att hämta, men tar inte bort, köhuvudet. |
| Object peek() | Denna metod används för att hämta, men tar inte bort, huvudet på denna kö, eller returnerar null om den här kön är tom. |
Fördelar med att använda Queue-gränssnittet i Java:
Ordningsbevarande : Kögränssnittet tillhandahåller ett sätt att lagra och hämta element i en specifik ordning, enligt principen först in, först ut (FIFO).
Flexibilitet : Kögränssnittet är en undertyp av Collection-gränssnittet, vilket innebär att det kan användas med många olika datastrukturer och algoritmer, beroende på applikationens krav.
Tråd – säkerhet : Vissa implementeringar av Queue-gränssnittet, som klassen java.util.concurrent.ConcurrentLinkedQueue, är trådsäkra, vilket innebär att de kan nås av flera trådar samtidigt utan att orsaka konflikter.
Prestanda : Kögränssnittet tillhandahåller effektiva implementeringar för att lägga till, ta bort och inspektera element, vilket gör det till ett användbart verktyg för att hantera samlingar av element i prestandakritiska applikationer.
Nackdelar med att använda Queue-gränssnittet i Java:
Begränsad funktionalitet: Kögränssnittet är designat specifikt för att hantera samlingar av element i en specifik ordning, vilket innebär att det kanske inte är lämpligt för mer komplexa datastrukturer eller algoritmer.
Storleksbegränsningar: Vissa implementeringar av Queue-gränssnittet, som klassen ArrayDeque, har en fast storlek, vilket innebär att de inte kan växa utöver ett visst antal element.
Minnesanvändning: Beroende på implementeringen kan Queue-gränssnittet kräva mer minne än andra datastrukturer, särskilt om det behöver lagra ytterligare information om elementens ordning.
Komplexitet : Kögränssnittet kan vara svårt att använda och förstå för nybörjare, speciellt om de inte är bekanta med principerna för datastrukturer och algoritmer.