java queue queue methods
In questo tutorial, discuteremo di cos'è una coda in Java, come usarla, esempio di coda Java, metodi di coda Java e implementazione dell'interfaccia di coda:
Una coda è una struttura dati lineare o una raccolta in Java che memorizza gli elementi in un ordine FIFO (First In, First Out).
La raccolta delle code ha due estremità, ovvero anteriore e posteriore. Gli elementi vengono aggiunti nella parte posteriore e rimossi dalla parte anteriore.
=> Visita qui per vedere la serie di formazione Java per tutti.
Cosa imparerai:
Che cos'è una coda Java?
Una struttura dei dati della coda è rappresentata come mostrato di seguito:
Come mostrato nel diagramma sopra, una coda è una struttura con due punti, cioè inizio (davanti) e fine (dietro). Gli elementi vengono inseriti nella coda nella parte posteriore e rimossi dalla coda nella parte anteriore.
In Java, Queue è un'interfaccia che fa parte del pacchetto java.util. L'interfaccia della coda estende l'interfaccia della raccolta Java.
La definizione generale dell'interfaccia Queue è:
public interface Queue extends CollectionPoiché la coda è un'interfaccia, non è possibile crearne un'istanza. Abbiamo bisogno di alcune classi concrete per implementare la funzionalità dell'interfaccia Queue. Due classi implementano l'interfaccia Queue, ovvero LinkedList e PriorityQueue.
Di seguito sono riportate alcune delle principali caratteristiche della struttura dei dati della coda:
- La coda segue l'ordine FIFO (First In, First Out). Ciò significa che l'elemento viene inserito nella coda alla fine e rimosso dalla coda all'inizio.
- L'interfaccia della coda Java fornisce tutti i metodi dell'interfaccia di raccolta come inserimento, eliminazione, ecc.
- LinkedList e PriorityQueue sono le classi che implementano l'interfaccia Queue. ArrayBlockingQueue è ancora un'altra classe che implementa l'interfaccia Queue.
- Le code che fanno parte del pacchetto java.util possono essere classificate come code illimitate mentre quelle presenti in java.util.il pacchetto concorrente sono code limitate.
- Il Deque è una coda che supporta l'inserimento e la cancellazione da entrambe le estremità.
- Il deque è thread-safe.
- Le BlockingQueues sono thread-safe e vengono utilizzate per implementare i problemi produttore-consumatore.
- BlockingQueues non consente elementi null. Viene generata un'eccezione NullPointerException se si tenta di eseguire qualsiasi operazione correlata a valori null.
Come utilizzare una coda in Java?
Per utilizzare una coda in Java, dobbiamo prima importare l'interfaccia della coda come segue:
import java.util.queue; O
import java.util.*; Una volta importato, possiamo creare una coda come mostrato di seguito:
Queue str_queue = new LinkedList (); Poiché Queue è un'interfaccia, utilizziamo una classe LinkedList che implementa l'interfaccia Queue per creare un oggetto coda.
Allo stesso modo, possiamo creare una coda con altre classi concrete.
Queue str_pqueue = new PriorityQueue (); Queue int_queue = new ArrayDeque (); Ora che l'oggetto coda è stato creato, possiamo inizializzare l'oggetto coda fornendogli i valori tramite il metodo add come mostrato di seguito.
str_queue.add(“one”); str_queue.add(“two”); str_queue.add(“three”);Esempio di coda Java
import java.util.*; public class Main { public static void main(String() args) { //declare a Queue Queue str_queue = new LinkedList(); //initialize the queue with values str_queue.add('one'); str_queue.add('two'); str_queue.add('three'); str_queue.add('four'); //print the Queue System.out.println('The Queue contents:' + str_queue); } }Produzione:
I contenuti della coda: (uno, due, tre, quattro)
L'esempio precedente mostra la dichiarazione e l'inizializzazione di un oggetto Queue. Quindi, stampiamo solo il contenuto della coda.
Metodi di coda in Java
In questa sezione, discuteremo i metodi dell'API per la coda. L'interfaccia della coda supporta varie operazioni come inserire, eliminare, sbirciare, ecc. Alcune operazioni sollevano un'eccezione mentre altre restituiscono un valore specifico quando il metodo riesce o fallisce.
Si noti che non sono state apportate modifiche specifiche alla raccolta delle code in Java 8. I metodi seguenti sono disponibili anche nelle versioni successive di Java come Java 9, ecc.
La tabella seguente riassume tutti questi metodi.
| Metodo | Metodo Prototipo | Descrizione |
|---|---|---|
| taglia | int size () | Restituisce la dimensione o il numero di elementi nella coda. |
| Inserisci | booleano add (E e) | Aggiunge l'elemento e alla coda alla fine (coda) della coda senza violare le restrizioni sulla capacità. Restituisce true se ha esito positivo o IllegalStateException se la capacità è esaurita. |
| sbirciare | E sbircia () | Restituisce la testa (davanti) della coda senza rimuoverla. |
| elemento | E elemento () | Esegue la stessa operazione del metodo peek (). Genera NoSuchElementException quando la coda è vuota. |
| rimuovere | E rimuovi () | Rimuove la testa della coda e la restituisce. Genera NoSuchElementException se la coda è vuota. |
| sondaggio | E sondaggio () | Rimuove la testa della coda e la restituisce. Se la coda è vuota, restituisce null. |
| Offrire | offerta booleana (E e) | Inserisci il nuovo elemento e nella coda senza violare le limitazioni di capacità. |
Iterazione degli elementi della coda
Possiamo attraversare gli elementi della coda utilizzando il ciclo forEach o un iteratore. Il programma fornito di seguito implementa entrambi gli approcci per attraversare la coda.
import java.util.*; public class Main { public static void main(String() args) { //declare a Queue Queue LL_queue = new LinkedList(); //initialize the Queue LL_queue.add('Value-0'); LL_queue.add('Value-1'); LL_queue.add('Value-2'); LL_queue.add('Value-3'); //traverse the Queue using Iterator System.out.println('The Queue elements through iterator:'); Iterator iterator = LL_queue.iterator(); while(iterator.hasNext()){ String element = (String) iterator.next(); System.out.print(element + ' '); } System.out.println('
The Queue elements using for loop:'); //use new for loop to traverse the Queue for(Object object : LL_queue) { String element = (String) object; System.out.print(element + ' '); } } }Produzione:
Gli elementi della coda tramite iteratore:
Valore-0 Valore-1 Valore-2 Valore-3
Gli elementi Queue che utilizzano il ciclo for:
Valore-0 Valore-1 Valore-2 Valore-3
Implementazione della coda Java
Il programma seguente mostra i metodi che abbiamo discusso sopra.
import java.util.*; public class Main { public static void main(String() args) { Queue q1 = new LinkedList(); //Add elements to the Queue q1.add(10); q1.add(20); q1.add(30); q1.add(40); q1.add(50); System.out.println('Elements in Queue:'+q1); //remove () method =>removes first element from the queue System.out.println('Element removed from the queue: '+q1.remove()); //element() => returns head of the queue System.out.println('Head of the queue: '+q1.element()); //poll () => removes and returns the head System.out.println('Poll():Returned Head of the queue: '+q1.poll()); //returns head of the queue System.out.println('peek():Head of the queue: '+q1.peek()); //print the contents of the Queue System.out.println('Final Queue:'+q1); } } Produzione:
Elementi in coda: (10, 20, 30, 40, 50)
Elemento rimosso dalla coda: 10
Capo della coda: 20
Poll (): capo della coda restituito: 20
peek (): Capo della coda: 30
Coda finale: (30, 40, 50)
Implementazione di Java Queue Array
L'implementazione della coda non è così semplice come un'implementazione dello stack. Prima di tutto, la coda contiene due puntatori, posteriore e anteriore. Inoltre, operazioni diverse vengono eseguite a due estremità diverse.
Per implementare la coda utilizzando gli array, prima dichiariamo un array che conterrà n numero di elementi della coda.
Quindi definiamo le seguenti operazioni da eseguire in questa coda.
# 1) Accoda: Un'operazione per inserire un elemento nella coda è Enqueue (funzione queueEnqueue nel programma). Per inserire un elemento all'estremità posteriore, dobbiamo prima controllare se la coda è piena. Se è pieno, non possiamo inserire l'elemento. Se posteriore # 2) Dequeue: L'operazione per eliminare un elemento dalla coda è Dequeue (funzione queueDequeue nel programma). Innanzitutto, controlliamo se la coda è vuota. Affinché l'operazione di rimozione dalla coda funzioni, deve essere presente almeno un elemento nella coda. # 3) Anteriore: Questo metodo restituisce la parte anteriore della coda. # 4) Display: Questo metodo attraversa la coda e visualizza gli elementi della coda. Il seguente programma Java mostra l'implementazione Array di Queue. Produzione: Coda iniziale: Poiché abbiamo implementato la struttura dei dati della coda utilizzando gli array nel programma sopra, possiamo anche implementare la coda utilizzando l'elenco collegato. In questo programma implementeremo gli stessi metodi enqueue, dequeue, front e display. La differenza è che utilizzeremo la struttura dei dati dell'elenco collegato invece di Array. Il programma seguente mostra l'implementazione dell'elenco collegato di Queue in Java. Produzione: Elemento 6 aggiunto alla coda BlockingQueue è un'interfaccia aggiunta in Java 1.5 e fa parte di java.util.concurrent pacchetto. Questa interfaccia introduce il blocco nel caso in cui BlockingQueue sia pieno o vuoto. Pertanto, quando un thread accede alla coda e cerca di inserire (accodare) elementi in una coda che è già piena viene bloccato fino a quando un altro thread crea uno spazio nella coda (forse mediante un'operazione di rimozione dalla coda o di cancellazione della coda). Allo stesso modo, in caso di rimozione dalla coda, l'operazione viene bloccata se la coda è vuota fino a quando l'elemento non diventa disponibile per l'operazione di rimozione dalla coda. I metodi BlockingQueue utilizzano una qualche forma di controllo della concorrenza come i blocchi interni e sono atomici. BlockingQueue è una coda simultanea che gestisce le operazioni della coda contemporaneamente. La BlockingQueue è mostrata di seguito: Notare che BlockingQueue non accetta valori null. Un tentativo di inserire un valore null nella coda genera NullPointerException. Alcune delle implementazioni di BlockingQueue fornite in Java sono LinkedBlockingQueue, PriorityBlockingQueue, ArrayBlockingQueue e SynchonousQueue. Tutte queste implementazioni sono thread-safe. Le BlockingQueues sono di due tipi: Nella coda delimitata, la capacità della coda viene passata al costruttore della coda. La dichiarazione della coda è la seguente: BlockingQueue blockingQueue = nuovo LinkedBlockingDeque (5); Nella coda illimitata, non impostiamo la capacità della coda in modo esplicito e può aumentare di dimensioni. La capacità è impostata su Integer.MAX_VALUE. La dichiarazione della coda illimitata è la seguente: BlockingQueue blockingQueue = nuovo LinkedBlockingDeque (); L'interfaccia BlockingQueue viene utilizzata principalmente per i tipi di problemi produttore-consumatore in cui il produttore produce le risorse e il consumatore consuma le risorse. D # 1) Che cos'è una coda in Java? Risposta: La coda in Java è una struttura dati ordinata lineare che segue l'ordine FIFO (First In, First Out) degli elementi. Ciò significa che l'elemento inserito per primo nella coda sarà il primo elemento ad essere rimosso. In Java, la coda è implementata come un'interfaccia che eredita l'interfaccia Collection. Q # 2) È un Java thread-safe di Queue? Risposta: Non tutte le code sono thread-safe, ma le BlockingQueues in Java sono thread-safe. Q # 3) Qual è il più veloce: Stack o Queue? Risposta: Lo stack è più veloce. Nello stack, gli elementi vengono elaborati da una sola estremità, quindi non è richiesto alcuno spostamento. Ma nella coda, gli elementi devono essere spostati e regolati poiché ci sono due diversi puntatori per inserire ed eliminare elementi. Q # 4) Quali sono i tipi di coda? Risposta: le code sono dei seguenti tipi: Q # 5) Perché viene utilizzata la coda? Risposta: La struttura dei dati della coda viene utilizzata per scopi di sincronizzazione. La coda viene utilizzata anche per la pianificazione del disco e della CPU. In questo tutorial, abbiamo discusso le code semplici insieme ai loro dettagli come dichiarazioni, implementazione dell'inizializzazione e metodi. Abbiamo anche appreso dell'implementazione Array e LinkedList di Queue in Java. Nei nostri prossimi tutorial, discuteremo in dettaglio più tipi di code. => Controlla TUTTI i tutorial Java qui. class Queue { private static int front, rear, capacity; private static int queue(); Queue(int size) { front = rear = 0; capacity = size; queue = new int(capacity); } // insert an element into the queue static void queueEnqueue(int item) { // check if the queue is full if (capacity == rear) { System.out.printf('
Queue is full
'); return; } // insert element at the rear else { queue(rear) = item; rear++; } return; } //remove an element from the queue static void queueDequeue() { // check if queue is empty if (front == rear) { System.out.printf('
Queue is empty
'); return; } // shift elements to the right by one place uptil rear else { for (int i = 0; i
La coda è vuota
Coda dopo l'operazione di accodamento:
10 = 30 = 50 = 70 =
Elemento anteriore della coda: 10
La coda è piena
10 = 30 = 50 = 70 =
Coda dopo due operazioni di rimozione dalla coda: 50 = 70 =
Elemento anteriore della coda: 50
Implementazione dell'elenco collegato delle code Java
class LinkedListQueue { private Node front, rear; private int queueSize; // queue size //linked list node private class Node { int data; Node next; } //default constructor - initially front & rear are null; size=0; queue is empty public LinkedListQueue() { front = null; rear = null; queueSize = 0; } //check if the queue is empty public boolean isEmpty() { return (queueSize == 0); } //Remove item from the front of the queue. public int dequeue() { int data = front.data; front = front.next; if (isEmpty()) { rear = null; } queueSize--; System.out.println('Element ' + data+ ' removed from the queue'); return data; } //Add data at the rear of the queue. public void enqueue(int data) { Node oldRear = rear; rear = new Node(); rear.data = data; rear.next = null; if (isEmpty()) { front = rear; } else { oldRear.next = rear; } queueSize++; System.out.println('Element ' + data+ ' added to the queue'); } //print front and rear of the queue public void print_frontRear() { System.out.println('Front of the queue:' + front.data + ' Rear of the queue:' + rear.data); } } class Main{ public static void main(String a()){ LinkedListQueue queue = new LinkedListQueue(); queue.enqueue(6); queue.enqueue(3); queue.print_frontRear(); queue.enqueue(12); queue.enqueue(24); queue.dequeue(); queue.dequeue(); queue.enqueue(9); queue.print_frontRear(); } }
Elemento 3 aggiunto alla coda
Parte anteriore della coda: 6 Parte posteriore della coda: 3
Elemento 12 aggiunto alla coda
Elemento 24 aggiunto alla coda
Elemento 6 rimosso dalla coda
Elemento 3 rimosso dalla coda
Elemento 9 aggiunto alla coda
Parte anteriore della coda: 12 Parte posteriore della coda: 9
BlockingQueue In Java
Tipi di coda di blocco
Coda limitata
Coda illimitata
Domande frequenti
migliori programmi gratuiti per ottimizzare il PC
Conclusione
Lettura consigliata