L'interfaccia Coda è presente in java.util pacchetto ed estende il Interfaccia di raccolta viene utilizzato per contenere gli elementi che stanno per essere elaborati in ordine FIFO (First In First Out). È un elenco ordinato di oggetti il cui utilizzo è limitato all'inserimento di elementi alla fine dell'elenco e alla cancellazione di elementi dall'inizio dell'elenco, (cioè), segue il FIFO o il principio first-in-first-out.
Essendo un'interfaccia la coda necessita di una classe concreta per la dichiarazione e le classi più comuni sono the PriorityQueue E Lista collegata a Giava. Tieni presente che nessuna di queste implementazioni è thread-safe. PriorityBlockingQueue è un'implementazione alternativa se è necessaria l'implementazione thread-safe.
Dichiarazione: L'interfaccia Queue è dichiarata come:
public interface Queue extends Collection>
Creazione di oggetti coda: Da Coda è un interfaccia , non è possibile creare oggetti della coda dei tipi. Abbiamo sempre bisogno di una classe che estenda questo elenco per creare un oggetto. E inoltre, dopo l'introduzione di Generici in Java 1.5 è possibile limitare il tipo di oggetto che può essere memorizzato nella coda. Questa coda indipendente dai tipi può essere definita come:
// Obj is the type of the object to be stored in Queue Queue queue = new PriorityQueue ();>
In Java, l'interfaccia Queue è un sottotipo dell'interfaccia Collection e rappresenta una raccolta di elementi in un ordine specifico. Segue il principio FIFO (first-in, first-out), il che significa che gli elementi vengono recuperati nell'ordine in cui sono stati aggiunti alla coda.
L'interfaccia Queue fornisce diversi metodi per aggiungere, rimuovere e controllare gli elementi nella coda. Ecco alcuni dei metodi più comunemente utilizzati:
add(element): aggiunge un elemento in fondo alla coda. Se la coda è piena, genera un'eccezione.
offer(element): aggiunge un elemento in fondo alla coda. Se la coda è piena, restituisce false.
rimuovi(): rimuove e restituisce l'elemento in primo piano nella coda. Se la coda è vuota, genera un'eccezione.
poll(): rimuove e restituisce l'elemento in primo piano nella coda. Se la coda è vuota, restituisce null.
element(): restituisce l'elemento in testa alla coda senza rimuoverlo. Se la coda è vuota, genera un'eccezione.
peek(): restituisce l'elemento in testa alla coda senza rimuoverlo. Se la coda è vuota, restituisce null.
L'interfaccia Queue è implementata da diverse classi in Java, tra cui LinkedList, ArrayDeque e PriorityQueue. Ognuna di queste classi fornisce diverse implementazioni dell'interfaccia della coda, con caratteristiche e caratteristiche prestazionali diverse.
Nel complesso, l'interfaccia Queue è uno strumento utile per gestire raccolte di elementi in un ordine specifico ed è ampiamente utilizzata in molte applicazioni e settori diversi.
stringa java
Esempio:
Giava
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);> >}> }> |
>
>Produzione
Queue: [apple, banana, cherry] Removed element: apple Queue after removal: [banana, cherry] Peeked element: banana Queue after peek: [banana, cherry, date]>
Esempio: Coda
Giava
// 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);> >}> }> |
>
>Produzione
Elements of queue [0, 1, 2, 3, 4] removed element-0 [1, 2, 3, 4] head of queue-1 Size of queue-4>
Operazioni sull'interfaccia della coda
Vediamo come eseguire alcune operazioni utilizzate di frequente sulla coda utilizzando il file Classe della coda prioritaria .
1. Aggiunta di elementi: Per aggiungere un elemento in una coda, possiamo usare il file metodo add() . L'ordine di inserimento non viene mantenuto in PriorityQueue. Gli elementi vengono memorizzati in base all'ordine di priorità che per impostazione predefinita è crescente.
Esempio
Giava
il sorriso più bello del mondo
// 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);> >}> }> |
>
>
converti char in int javaProduzione
[For, Geeks, Geeks]>
2. Rimozione di elementi: Per rimuovere un elemento da una coda, possiamo usare il metodo rimuovi(). Se sono presenti più oggetti di questo tipo, viene rimossa la prima occorrenza dell'oggetto. Oltre a ciò, il metodo poll() viene utilizzato anche per rimuovere la testa e restituirla.
Esempio
Giava
// 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);> >}> }> |
>
>Produzione
Initial Queue [For, Geeks, Geeks] After Remove [For, Geeks] Poll Method For Final Queue [Geeks]>
3. Iterazione della coda: Esistono diversi modi per scorrere la coda. Il modo più famoso è convertire la coda nell'array e attraversarla utilizzando il ciclo for. Tuttavia, la coda dispone anche di un iteratore integrato che può essere utilizzato per scorrere la coda.
Esempio
Giava
// 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() +>' '>);> >}> >}> }> |
>
>Produzione
For Geeks Geeks>
Caratteristiche di una coda: Di seguito le caratteristiche della coda:
- La coda viene utilizzata per inserire elementi alla fine della coda e rimuoverli dall'inizio della coda. Segue il concetto FIFO.
- La coda Java supporta tutti i metodi dell'interfaccia di raccolta inclusi inserimento, eliminazione, ecc.
- Lista collegata , ArrayBlockingQueue e PriorityQueue sono le implementazioni più utilizzate.
- Se viene eseguita un'operazione Null su BlockingQueues, viene generata NullPointerException.
- Le code disponibili nel pacchetto java.util sono code illimitate.
- Le code disponibili nel pacchetto java.util.concurrent sono le code delimitate.
- Tutte le code tranne le Deque supportano l'inserimento e la rimozione rispettivamente in coda e in testa alla coda. Le Deques supportano l'inserimento e la rimozione degli elementi su entrambe le estremità.
Classi che implementano l'interfaccia della coda:
1. Coda prioritaria: La classe PriorityQueue implementata nel framework della raccolta ci fornisce un modo per elaborare gli oggetti in base alla priorità. È noto che una coda segue l’algoritmo First-In-First-Out, ma a volte è necessario che gli elementi della coda vengano elaborati in base alla priorità, ecco che entra in gioco PriorityQueue. Vediamo come creare un oggetto coda utilizzando questa classe.
Esempio
Giava
// 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());> >}> }> |
>
>Produzione
10 10 15>
2. Lista collegata: LinkedList è una classe implementata nel framework della raccolta che implementa intrinsecamente il file Esempio
Giava
nomi di città negli Stati Uniti
// 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());> >}> }> |
>
>Produzione
10 10 20>
3. Coda di blocco prioritario: È da notare che entrambe le implementazioni, PriorityQueue e LinkedList non sono thread-safe. PriorityBlockingQueue è un'implementazione alternativa se è necessaria un'implementazione thread-safe. PriorityBlockingQueue è una coda di blocco illimitato che utilizza le stesse regole di ordinamento della classe PriorityQueue e fornisce il blocco delle operazioni di recupero.
Poiché non ha limiti, l'aggiunta di elementi a volte potrebbe non riuscire a causa del conseguente esaurimento delle risorse Errore di memoria esaurita . Vediamo come creare un oggetto coda utilizzando questa classe.
Esempio
Giava
// 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());> >}> }> |
>
>Produzione
10 10 15>
Metodi di interfaccia delle code
L'interfaccia della coda eredita tutti i metodi presenti nel file interfaccia delle collezioni implementando i seguenti metodi:
| Metodo | Descrizione |
|---|---|
| add(int indice, elemento) | Questo metodo viene utilizzato per aggiungere un elemento a un particolare indice nella coda. Quando viene passato un singolo parametro, aggiunge semplicemente l'elemento alla fine della coda. |
| addAll(int indice, raccolta raccolta) | Questo metodo viene utilizzato per aggiungere alla coda tutti gli elementi della raccolta specificata. Quando viene passato un singolo parametro, aggiunge tutti gli elementi della raccolta data alla fine della coda. |
| misurare() | Questo metodo viene utilizzato per restituire la dimensione della coda. |
| chiaro() | Questo metodo viene utilizzato per rimuovere tutti gli elementi nella coda. Tuttavia, il riferimento della coda creata viene comunque memorizzato. |
| rimuovere() | Questo metodo viene utilizzato per rimuovere l'elemento dalla parte anteriore della coda. |
| rimuovi(indice int) | Questo metodo rimuove un elemento dall'indice specificato. Sposta gli elementi successivi (se presenti) a sinistra e diminuisce i loro indici di 1. |
| rimuovi(elemento) | Questo metodo viene utilizzato per rimuovere e restituire la prima occorrenza dell'elemento specificato nella coda. |
| get(indice int) | Questo metodo restituisce gli elementi nell'indice specificato. |
| set(int indice, elemento) | Questo metodo sostituisce gli elementi in un dato indice con il nuovo elemento. Questa funzione restituisce l'elemento che è stato appena sostituito da un nuovo elemento. |
| indiceDi(elemento) | Questo metodo restituisce la prima occorrenza dell'elemento specificato o -1 se l'elemento non è presente in coda. |
| ultimoIndiceOf(elemento) | Questo metodo restituisce l'ultima occorrenza dell'elemento specificato o -1 se l'elemento non è presente in coda. |
| uguale(elemento) | Questo metodo viene utilizzato per confrontare l'uguaglianza dell'elemento dato con gli elementi della coda. |
| codice hash() | Questo metodo viene utilizzato per restituire il valore hashcode della coda specificata. |
| è vuoto() | Questo metodo viene utilizzato per verificare se la coda è vuota o meno. Restituisce vero se la coda è vuota, altrimenti falso. |
| contiene(elemento) | Questo metodo viene utilizzato per verificare se la coda contiene o meno l'elemento specificato. Restituisce vero se la coda contiene l'elemento. |
| contieneTutto(raccolta Collezione) | Questo metodo viene utilizzato per verificare se la coda contiene tutta la raccolta di elementi. |
| sort(Comparatore comp) | Questo metodo viene utilizzato per ordinare gli elementi della coda in base a quanto indicato comparatore . |
| aggiunta booleana(oggetto) | Questo metodo viene utilizzato per inserire l'elemento specificato in una coda e restituire true in caso di successo. |
| offerta booleana(oggetto) | Questo metodo viene utilizzato per inserire l'elemento specificato nella coda. |
| Sondaggio oggetto() | Questo metodo viene utilizzato per recuperare e rimuovere l'inizio della coda o restituisce null se la coda è vuota. |
| Elemento oggetto() | Questo metodo viene utilizzato per recuperare, ma non rimuovere, l'inizio della coda. |
| Sbirciatina dell'oggetto() | Questo metodo viene utilizzato per recuperare, ma non rimuovere, l'inizio di questa coda o restituisce null se questa coda è vuota. |
Vantaggi dell'utilizzo dell'interfaccia Queue in Java:
Conservazione dell'ordine : l'interfaccia Queue fornisce un modo per archiviare e recuperare elementi in un ordine specifico, seguendo il principio FIFO (first-in, first-out).
proposizione logica
Flessibilità : L'interfaccia Queue è un sottotipo dell'interfaccia Collection, il che significa che può essere utilizzata con molte strutture dati e algoritmi diversi, a seconda dei requisiti dell'applicazione.
Filo – sicurezza : alcune implementazioni dell'interfaccia Queue, come la classe java.util.concurrent.ConcurrentLinkedQueue, sono thread-safe, il che significa che è possibile accedervi da più thread contemporaneamente senza causare conflitti.
Prestazione : l'interfaccia Queue fornisce implementazioni efficienti per l'aggiunta, la rimozione e il controllo degli elementi, rendendolo uno strumento utile per la gestione di raccolte di elementi in applicazioni critiche per le prestazioni.
Svantaggi dell'utilizzo dell'interfaccia Queue in Java:
Funzionalità limitate: L'interfaccia Queue è progettata specificamente per la gestione di raccolte di elementi in un ordine specifico, il che significa che potrebbe non essere adatta per strutture dati o algoritmi più complessi.
Restrizioni sulle dimensioni: Alcune implementazioni dell'interfaccia Queue, come la classe ArrayDeque, hanno una dimensione fissa, il che significa che non possono crescere oltre un certo numero di elementi.
Utilizzo della memoria: A seconda dell'implementazione, l'interfaccia Queue potrebbe richiedere più memoria rispetto ad altre strutture dati, soprattutto se deve memorizzare informazioni aggiuntive sull'ordine degli elementi.
Complessità : L'interfaccia Queue può essere difficile da utilizzare e comprendere per i programmatori alle prime armi, soprattutto se non hanno familiarità con i principi delle strutture dati e degli algoritmi.