De wachtrij-interface is aanwezig in java.util pakket en breidt de Verzamelinterface wordt gebruikt om de elementen vast te houden die op het punt staan te worden verwerkt in FIFO-volgorde (First In First Out). Het is een geordende lijst met objecten waarvan het gebruik beperkt is tot het invoegen van elementen aan het einde van de lijst en het verwijderen van elementen aan het begin van de lijst (dat wil zeggen: het volgt de FIFO of het First-In-First-Out-principe.
Omdat het een interface is, heeft de wachtrij een concrete klasse nodig voor de declaratie en de meest voorkomende klassen zijn de Prioriteits-rij En GelinkteLijst op Java. Merk op dat geen van deze implementaties thread-safe is. PrioriteitBlockingQueue is een alternatieve implementatie als de thread-safe implementatie nodig is.
Verklaring: De wachtrij-interface wordt gedeclareerd als:
public interface Queue extends Collection>
Wachtrijobjecten maken: Sinds Wachtrij is een koppel , kunnen er geen objecten van het type wachtrij worden gemaakt. We hebben altijd een klasse nodig die deze lijst uitbreidt om een object te maken. En ook, na de introductie van Merkloos product in Java 1.5 is het mogelijk om het type object dat in de wachtrij kan worden opgeslagen te beperken. Deze typeveilige wachtrij kan worden gedefinieerd als:
// Obj is the type of the object to be stored in Queue Queue queue = new PriorityQueue ();>
In Java is de Queue-interface een subtype van de Collection-interface en vertegenwoordigt een verzameling elementen in een specifieke volgorde. Het volgt het first-in, first-out (FIFO)-principe, wat betekent dat de elementen worden opgehaald in de volgorde waarin ze aan de wachtrij zijn toegevoegd.
De wachtrij-interface biedt verschillende methoden voor het toevoegen, verwijderen en inspecteren van elementen in de wachtrij. Hier zijn enkele van de meest gebruikte methoden:
add(element): Voegt een element toe aan de achterkant van de wachtrij. Als de wachtrij vol is, wordt er een uitzondering gegenereerd.
offer(element): Voegt een element toe aan de achterkant van de wachtrij. Als de wachtrij vol is, retourneert deze false.
remove(): Verwijdert en retourneert het element vooraan in de wachtrij. Als de wachtrij leeg is, genereert deze een uitzondering.
poll(): Verwijdert en retourneert het element vooraan in de wachtrij. Als de wachtrij leeg is, retourneert deze null.
element(): Retourneert het element vooraan in de wachtrij zonder het te verwijderen. Als de wachtrij leeg is, genereert deze een uitzondering.
peek(): Retourneert het element vooraan in de wachtrij zonder het te verwijderen. Als de wachtrij leeg is, retourneert deze null.
De Queue-interface wordt geïmplementeerd door verschillende klassen in Java, waaronder LinkedList, ArrayDeque en PriorityQueue. Elk van deze klassen biedt verschillende implementaties van de wachtrij-interface, met verschillende prestatiekenmerken en -functies.
Over het geheel genomen is de Queue-interface een handig hulpmiddel voor het beheren van verzamelingen elementen in een specifieke volgorde, en wordt veel gebruikt in veel verschillende toepassingen en industrieën.
de string omkeren in Java
Voorbeeld:
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);> >}> }> |
>
>Uitvoer
Queue: [apple, banana, cherry] Removed element: apple Queue after removal: [banana, cherry] Peeked element: banana Queue after peek: [banana, cherry, date]>
Voorbeeld: Wachtrij
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);> >}> }> |
>
>Uitvoer
Elements of queue [0, 1, 2, 3, 4] removed element-0 [1, 2, 3, 4] head of queue-1 Size of queue-4>
Bewerkingen op wachtrij-interface
Laten we eens kijken hoe we een aantal veelgebruikte bewerkingen in de wachtrij kunnen uitvoeren met behulp van de Prioriteitswachtrijklasse .
1. Elementen toevoegen: Om een element aan een wachtrij toe te voegen, kunnen we de add() methode . De invoegopdracht wordt niet bewaard in de PriorityQueue. De elementen worden opgeslagen op basis van de prioriteitsvolgorde, die standaard oplopend is.
Voorbeeld
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);> >}> }> |
>
>
converteer nfa naar dfaUitvoer
[For, Geeks, Geeks]>
2. Elementen verwijderen: Om een element uit een wachtrij te verwijderen, kunnen we de verwijder() methode. Als er meerdere van dergelijke objecten zijn, wordt het eerste exemplaar van het object verwijderd. Daarnaast wordt de methode poll() ook gebruikt om de kop te verwijderen en terug te sturen.
Voorbeeld
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);> >}> }> |
>
>Uitvoer
Initial Queue [For, Geeks, Geeks] After Remove [For, Geeks] Poll Method For Final Queue [Geeks]>
3. De wachtrij herhalen: Er zijn meerdere manieren om door de wachtrij te lopen. De bekendste manier is het converteren van de wachtrij naar de array en het doorlopen ervan met behulp van de for-lus. De wachtrij heeft echter ook een ingebouwde iterator die kan worden gebruikt om door de wachtrij te itereren.
Voorbeeld
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() +>' '>);> >}> >}> }> |
>
>Uitvoer
For Geeks Geeks>
Kenmerken van een wachtrij: Dit zijn de kenmerken van de wachtrij:
- De wachtrij wordt gebruikt om elementen aan het einde van de wachtrij in te voegen en te verwijderen vanaf het begin van de wachtrij. Het volgt het FIFO-concept.
- De Java Queue ondersteunt alle methoden van de verzamelinterface, inclusief invoegen, verwijderen, enz.
- GelinkteLijst , ArrayBlockingQueue en Prioriteits-rij zijn de meest gebruikte implementaties.
- Als er een null-bewerking wordt uitgevoerd op BlockingQueues, wordt NullPointerException gegenereerd.
- De wachtrijen die beschikbaar zijn in het java.util-pakket zijn onbegrensde wachtrijen.
- De wachtrijen die beschikbaar zijn in het pakket java.util.concurrent zijn de begrensde wachtrijen.
- Alle wachtrijen behalve de Deques ondersteunen respectievelijk het inbrengen en verwijderen aan de staart en het begin van de wachtrij. Het Deques-steunelement wordt aan beide uiteinden ingebracht en verwijderd.
Klassen die de wachtrij-interface implementeren:
1. Prioriteitswachtrij: De klasse PriorityQueue die in het verzamelingsframework is geïmplementeerd, biedt ons een manier om de objecten te verwerken op basis van de prioriteit. Het is bekend dat een wachtrij het First-In-First-Out-algoritme volgt, maar soms moeten de elementen van de wachtrij worden verwerkt volgens de prioriteit, en dan komt de PriorityQueue in het spel. Laten we eens kijken hoe we met deze klasse een wachtrijobject kunnen maken.
Voorbeeld
Java
Hoe een bestand in Java te openen
// 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());> >}> }> |
>
>Uitvoer
10 10 15>
2. Gekoppelde lijst: LinkedList is een klasse die is geïmplementeerd in het verzamelframework dat inherent de Voorbeeld
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());> >}> }> |
>
>Uitvoer
10 10 20>
3. PrioriteitBlockingQueue: Opgemerkt moet worden dat beide implementaties, de PriorityQueue en LinkedList, niet thread-safe zijn. PriorityBlockingQueue is een alternatieve implementatie als een threadveilige implementatie nodig is. PriorityBlockingQueue is een onbegrensde blokkeerwachtrij die dezelfde volgorderegels gebruikt als klasse Prioriteits-rij en benodigdheden die de ophaaloperaties blokkeren.
Omdat het onbegrensd is, kan het toevoegen van elementen soms mislukken als gevolg van uitputting van de middelen Onvoldoende geheugen fout . Laten we eens kijken hoe we met deze klasse een wachtrijobject kunnen maken.
Voorbeeld
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());> >}> }> |
>
>Uitvoer
10 10 15>
Methoden voor wachtrij-interface
De wachtrij-interface erft alle methoden die aanwezig zijn in de collecties-interface terwijl u de volgende methoden implementeert:
| Methode | Beschrijving |
|---|---|
| add(int index, element) | Deze methode wordt gebruikt om een element toe te voegen aan een bepaalde index in de wachtrij. Wanneer een enkele parameter wordt doorgegeven, wordt eenvoudigweg het element aan het einde van de wachtrij toegevoegd. |
| addAll(int index, Verzamelingverzameling) | Deze methode wordt gebruikt om alle elementen in de gegeven verzameling aan de wachtrij toe te voegen. Wanneer een enkele parameter wordt doorgegeven, worden alle elementen van de gegeven verzameling aan het einde van de wachtrij toegevoegd. |
| maat() | Deze methode wordt gebruikt om de grootte van de wachtrij te retourneren. |
| duidelijk() | Deze methode wordt gebruikt om alle elementen in de wachtrij te verwijderen. De referentie van de aangemaakte wachtrij wordt echter nog steeds opgeslagen. |
| verwijderen() | Deze methode wordt gebruikt om het element vooraan in de wachtrij te verwijderen. |
| verwijder(int index) | Deze methode verwijdert een element uit de opgegeven index. Het verschuift de daaropvolgende elementen (indien aanwezig) naar links en verlaagt hun indexen met 1. |
| verwijder(element) | Deze methode wordt gebruikt om het eerste exemplaar van het gegeven element in de wachtrij te verwijderen en terug te sturen. |
| get(int-index) | Deze methode retourneert elementen op de opgegeven index. |
| set(int index, element) | Deze methode vervangt elementen op een bepaalde index door het nieuwe element. Deze functie retourneert het element dat zojuist is vervangen door een nieuw element. |
| indexOf(element) | Deze methode retourneert de eerste keer dat het gegeven element voorkomt of -1 als het element niet in de wachtrij aanwezig is. |
| laatsteIndexOf(element) | Deze methode retourneert de laatste keer dat het gegeven element voorkomt of -1 als het element niet in de wachtrij aanwezig is. |
| is gelijk aan(element) | Deze methode wordt gebruikt om de gelijkheid van het gegeven element met de elementen van de wachtrij te vergelijken. |
| hashCode() | Deze methode wordt gebruikt om de hashcodewaarde van de gegeven wachtrij te retourneren. |
| is leeg() | Deze methode wordt gebruikt om te controleren of de wachtrij leeg is of niet. Het retourneert waar als de wachtrij leeg is, anders onwaar. |
| bevat(element) | Deze methode wordt gebruikt om te controleren of de wachtrij het gegeven element bevat of niet. Het retourneert waar als de wachtrij het element bevat. |
| bevatAll(collectieverzameling) | Deze methode wordt gebruikt om te controleren of de wachtrij de volledige verzameling elementen bevat. |
| sort(vergelijkingsvergelijking) | Deze methode wordt gebruikt om de elementen van de wachtrij te sorteren op basis van het gegeven comparator . |
| Booleaanse toevoeging(object) | Deze methode wordt gebruikt om het opgegeven element in een wachtrij in te voegen en bij succes True terug te geven. |
| Booleaanse aanbieding(object) | Deze methode wordt gebruikt om het opgegeven element in de wachtrij in te voegen. |
| Objectenquête() | Deze methode wordt gebruikt om de kop van de wachtrij op te halen en te verwijderen, of retourneert null als de wachtrij leeg is. |
| Objectelement() | Deze methode wordt gebruikt om het hoofd van de wachtrij op te halen, maar niet te verwijderen. |
| Object kijkje() | Deze methode wordt gebruikt om de kop van deze wachtrij op te halen, maar niet te verwijderen, of retourneert nul als deze wachtrij leeg is. |
Voordelen van het gebruik van de Queue-interface in Java:
Behoud van bestellingen : De Queue-interface biedt een manier om elementen in een specifieke volgorde op te slaan en op te halen, volgens het first-in, first-out (FIFO)-principe.
zoek in tekenreeks c++
Flexibiliteit : De Queue-interface is een subtype van de Collection-interface, wat betekent dat deze kan worden gebruikt met veel verschillende datastructuren en algoritmen, afhankelijk van de vereisten van de applicatie.
Draad – veiligheid : Sommige implementaties van de Queue-interface, zoals de klasse java.util.concurrent.ConcurrentLinkedQueue, zijn thread-safe, wat betekent dat ze door meerdere threads tegelijk kunnen worden benaderd zonder conflicten te veroorzaken.
Prestatie : De Queue-interface biedt efficiënte implementaties voor het toevoegen, verwijderen en inspecteren van elementen, waardoor het een handig hulpmiddel is voor het beheren van verzamelingen elementen in prestatiekritische applicaties.
Nadelen van het gebruik van de Queue-interface in Java:
Beperkte functionaliteit: De Queue-interface is specifiek ontworpen voor het beheren van verzamelingen elementen in een specifieke volgorde, wat betekent dat deze mogelijk niet geschikt is voor complexere datastructuren of algoritmen.
Groottebeperkingen: Sommige implementaties van de Queue-interface, zoals de klasse ArrayDeque, hebben een vaste grootte, wat betekent dat ze niet verder kunnen groeien dan een bepaald aantal elementen.
Geheugengebruik: Afhankelijk van de implementatie heeft de Queue-interface mogelijk meer geheugen nodig dan andere datastructuren, vooral als er aanvullende informatie over de volgorde van de elementen moet worden opgeslagen.
Complexiteit : De Queue-interface kan moeilijk te gebruiken en te begrijpen zijn voor beginnende programmeurs, vooral als ze niet bekend zijn met de principes van datastructuren en algoritmen.