La interfície de la cua està present a java.util paquet i amplia el Interfície de col·lecció s'utilitza per mantenir els elements a punt de ser processats en ordre FIFO (First In First Out). És una llista ordenada d'objectes amb el seu ús limitat a inserir elements al final de la llista i eliminar elements des de l'inici de la llista, (és a dir, segueix el FIFO o el principi del primer en entrar, primer en sortir.
En ser una interfície, la cua necessita una classe concreta per a la declaració i les classes més habituals són les PriorityQueue i LinkedList en Java. Tingueu en compte que cap d'aquestes implementacions és segura per a fils. PriorityBlockingQueue és una implementació alternativa si es necessita la implementació segura.
Declaració: La interfície de la cua es declara com:
public interface Queue extends Collection>
Creació d'objectes de cua: Des de Cua és un interfície , no es poden crear objectes del tipus cua. Sempre necessitem una classe que ampliï aquesta llista per crear un objecte. I també, després de la introducció de Genèrics a Java 1.5, és possible restringir el tipus d'objecte que es pot emmagatzemar a la cua. Aquesta cua de tipus segura es pot definir com:
// Obj is the type of the object to be stored in Queue Queue queue = new PriorityQueue ();>
A Java, la interfície de cua és un subtipus de la interfície de col·lecció i representa una col·lecció d'elements en un ordre específic. Segueix el principi de primer en entrar, primer en sortir (FIFO), que significa que els elements es recuperen en l'ordre en què s'han afegit a la cua.
La interfície de la cua ofereix diversos mètodes per afegir, eliminar i inspeccionar elements de la cua. Aquests són alguns dels mètodes més utilitzats:
add(element): afegeix un element a la part posterior de la cua. Si la cua està plena, genera una excepció.
offer(element): afegeix un element a la part posterior de la cua. Si la cua està plena, retorna false.
remove(): elimina i torna l'element al capdavant de la cua. Si la cua està buida, genera una excepció.
poll(): elimina i retorna l'element al capdavant de la cua. Si la cua està buida, retorna null.
element(): retorna l'element al capdavant de la cua sense eliminar-lo. Si la cua està buida, genera una excepció.
peek(): Retorna l'element al capdavant de la cua sense eliminar-lo. Si la cua està buida, retorna null.
La interfície Queue està implementada per diverses classes a Java, incloses LinkedList, ArrayDeque i PriorityQueue. Cadascuna d'aquestes classes ofereix diferents implementacions de la interfície de la cua, amb diferents característiques i característiques de rendiment.
En general, la interfície de la cua és una eina útil per gestionar col·leccions d'elements en un ordre específic i s'utilitza àmpliament en moltes aplicacions i indústries diferents.
Exemple:
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);> >}> }> |
>
>Sortida
Queue: [apple, banana, cherry] Removed element: apple Queue after removal: [banana, cherry] Peeked element: banana Queue after peek: [banana, cherry, date]>
Exemple: Cua
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);> >}> }> |
>
>Sortida
Elements of queue [0, 1, 2, 3, 4] removed element-0 [1, 2, 3, 4] head of queue-1 Size of queue-4>
Operacions a la interfície de cua
Vegem com realitzar algunes operacions d'ús freqüent a la cua mitjançant el Classe de cua de prioritat .
1. Afegir elements: Per afegir un element a una cua, podem utilitzar el mètode add(). . L'ordre d'inserció no es conserva a PriorityQueue. Els elements s'emmagatzemen en funció de l'ordre de prioritat que és ascendent per defecte.
Exemple
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);> >}> }> |
>
>Sortida
[For, Geeks, Geeks]>
2. Eliminació d'elements: Per eliminar un element d'una cua, podem utilitzar el mètode remove(). Si hi ha diversos objectes d'aquest tipus, s'elimina la primera ocurrència de l'objecte. A part d'això, el mètode poll() també s'utilitza per eliminar el cap i tornar-lo.
Exemple
Java
classe de matemàtiques 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);> >}> }> |
>
>Sortida
Initial Queue [For, Geeks, Geeks] After Remove [For, Geeks] Poll Method For Final Queue [Geeks]>
3. Iteració de la cua: Hi ha diverses maneres d'iterar a través de la cua. La manera més famosa és convertir la cua a la matriu i recórrer mitjançant el bucle for. Tanmateix, la cua també té un iterador integrat que es pot utilitzar per iterar a través de la cua.
Exemple
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() +>' '>);> >}> >}> }> |
>
>Sortida
For Geeks Geeks>
Característiques d'una cua: Aquestes són les característiques de la cua:
- La cua s'utilitza per inserir elements al final de la cua i s'elimina des del començament de la cua. Segueix el concepte FIFO.
- La cua Java admet tots els mètodes de la interfície de col·lecció, inclosa la inserció, la supressió, etc.
- LinkedList , ArrayBlockingQueue i PriorityQueue són les implementacions més utilitzades.
- Si es realitza alguna operació nul·la a BlockingQueues, es llança una NullPointerException.
- Les cues que estan disponibles al paquet java.util són cues il·limitades.
- Les cues que estan disponibles al paquet java.util.concurrent són les cues limitades.
- Totes les cues excepte les Deques admeten la inserció i l'eliminació a la cua i al capdavant de la cua respectivament. La inserció i retirada de l'element de suport Deques als dos extrems.
Classes que implementen la interfície de cua:
1. PriorityQueue: La classe PriorityQueue que s'implementa al marc de col·lecció ens proporciona una manera de processar els objectes en funció de la prioritat. Se sap que una cua segueix l'algorisme First-In-First-Out, però de vegades cal que els elements de la cua es processin segons la prioritat, és llavors quan entra en joc la PriorityQueue. Vegem com crear un objecte de cua amb aquesta classe.
Exemple
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());> >}> }> |
>
>Sortida
10 10 15>
2. Llista enllaçada: LinkedList és una classe que s'implementa en el marc de col·lecció que implementa de manera inherent el Exemple
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());> >}> }> |
>
>Sortida
10 10 20>
3. PriorityBlockingQueue: Cal tenir en compte que les dues implementacions, PriorityQueue i LinkedList no són segures per a fils. PriorityBlockingQueue és una implementació alternativa si es necessita una implementació segura. PriorityBlockingQueue és una cua de bloqueig il·limitada que utilitza les mateixes regles d'ordenació que la classe PriorityQueue i subministraments que bloquegen les operacions de recuperació.
Com que no té límits, l'addició d'elements pot fallar de vegades a causa de l'esgotament dels recursos OutOfMemoryError . Vegem com crear un objecte de cua amb aquesta classe.
Exemple
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());> >}> }> |
>
>Sortida
10 10 15>
Mètodes de la interfície de cua
La interfície de la cua hereta tots els mètodes presents al fitxer interfície de col·leccions tot implementant els mètodes següents:
| Mètode | Descripció |
|---|---|
| afegir (índex int, element) | Aquest mètode s'utilitza per afegir un element a un índex determinat de la cua. Quan es passa un únic paràmetre, simplement afegeix l'element al final de la cua. |
| addAll(índex int, col·lecció de col·lecció) | Aquest mètode s'utilitza per afegir tots els elements de la col·lecció donada a la cua. Quan es passa un únic paràmetre, afegeix tots els elements de la col·lecció donada al final de la cua. |
| mida () | Aquest mètode s'utilitza per retornar la mida de la cua. |
| clar () | Aquest mètode s'utilitza per eliminar tots els elements de la cua. Tanmateix, la referència de la cua creada encara està emmagatzemada. |
| eliminar () | Aquest mètode s'utilitza per eliminar l'element de la part davantera de la cua. |
| eliminar (índex int) | Aquest mètode elimina un element de l'índex especificat. Desplaça els elements posteriors (si n'hi ha) cap a l'esquerra i disminueix els seus índexs en 1. |
| eliminar (element) | Aquest mètode s'utilitza per eliminar i retornar la primera ocurrència de l'element donat a la cua. |
| obtenir (índex int) | Aquest mètode retorna elements a l'índex especificat. |
| set(índex int, element) | Aquest mètode substitueix els elements d'un índex determinat pel nou element. Aquesta funció retorna l'element que s'acaba de substituir per un nou element. |
| indexOf(element) | Aquest mètode retorna la primera ocurrència de l'element donat o -1 si l'element no està present a la cua. |
| lastIndexOf(element) | Aquest mètode retorna l'última ocurrència de l'element donat o -1 si l'element no està present a la cua. |
| és igual (element) | Aquest mètode s'utilitza per comparar la igualtat de l'element donat amb els elements de la cua. |
| hashCode() | Aquest mètode s'utilitza per retornar el valor del codi hash de la cua donada. |
| està buit() | Aquest mètode s'utilitza per comprovar si la cua està buida o no. Retorna true si la cua està buida, en cas contrari, false. |
| conté (element) | Aquest mètode s'utilitza per comprovar si la cua conté l'element donat o no. Retorna true si la cua conté l'element. |
| containsAll (Col·lecció de col·lecció) | Aquest mètode s'utilitza per comprovar si la cua conté tota la col·lecció d'elements. |
| ordenar (comparador de comparació) | Aquest mètode s'utilitza per ordenar els elements de la cua en funció del donat comparador . |
| afegir booleà (objecte) | Aquest mètode s'utilitza per inserir l'element especificat en una cua i retornar true en cas d'èxit. |
| oferta booleana (objecte) | Aquest mètode s'utilitza per inserir l'element especificat a la cua. |
| Enquesta d'objectes() | Aquest mètode s'utilitza per recuperar i eliminar el cap de la cua, o retorna null si la cua està buida. |
| Element d'objecte() | Aquest mètode s'utilitza per recuperar, però no eliminar, el cap de cua. |
| Vista de l'objecte() | Aquest mètode s'utilitza per recuperar, però no elimina, la capçalera d'aquesta cua o retorna null si aquesta cua està buida. |
Avantatges d'utilitzar la interfície Queue a Java:
Conservació de l'ordre : La interfície Queue proporciona una manera d'emmagatzemar i recuperar elements en un ordre específic, seguint el principi de primer en entrar, primer en sortir (FIFO).
Flexibilitat : La interfície de cua és un subtipus de la interfície de col·lecció, el que significa que es pot utilitzar amb moltes estructures de dades i algorismes diferents, depenent dels requisits de l'aplicació.
Fil – seguretat : Algunes implementacions de la interfície Queue, com ara la classe java.util.concurrent.ConcurrentLinkedQueue, són segures per a fils, el que significa que es pot accedir a elles per múltiples fils simultàniament sense causar conflictes.
Rendiment : La interfície Queue proporciona implementacions eficients per afegir, eliminar i inspeccionar elements, la qual cosa la converteix en una eina útil per gestionar col·leccions d'elements en aplicacions crítiques per al rendiment.
Desavantatges d'utilitzar la interfície Queue a Java:
Funcionalitat limitada: La interfície de la cua està dissenyada específicament per gestionar col·leccions d'elements en un ordre específic, la qual cosa significa que pot ser que no sigui adequada per a estructures de dades o algorismes més complexos.
Restriccions de mida: Algunes implementacions de la interfície Queue, com la classe ArrayDeque, tenen una mida fixa, el que significa que no poden créixer més enllà d'un nombre determinat d'elements.
Ús de memòria: Depenent de la implementació, la interfície de la cua pot requerir més memòria que altres estructures de dades, especialment si necessita emmagatzemar informació addicional sobre l'ordre dels elements.
Complexitat : La interfície de la cua pot ser difícil d'utilitzar i d'entendre per als programadors novells, especialment si no estan familiaritzats amb els principis de les estructures de dades i els algorismes.