Coda Java – Coda in Java

La coda Java è un’interfaccia disponibile nel pacchetto java.util e estende l’interfaccia java.util.Collection. Proprio come Java List, Java Queue è una collezione di elementi ordinati (o oggetti), ma esegue operazioni di inserimento e rimozione in modo diverso. Possiamo utilizzare la coda per memorizzare gli elementi prima di elaborarli.

Coda Java

In questa sezione, discuteremo alcuni dei punti importanti sulla Coda Java:

• java.util.Queue è una sottoclasse di java.util.Collection.
• Proprio come una coda del mondo reale (ad esempio, in una banca o in un bancomat), la coda inserisce gli elementi alla fine della coda e li rimuove dall’inizio della coda.
• La coda Java rappresenta un elenco ordinato di elementi.
• La coda Java segue l’ordine FIFO per inserire e rimuovere i suoi elementi. FIFO sta per First In First Out.
• La coda Java supporta tutti i metodi dell’interfaccia Collection.
• Le implementazioni di coda più utilizzate sono LinkedList, ArrayBlockingQueue e PriorityQueue.
• Le BlockingQueues non accettano elementi nulli. Se eseguiamo un’operazione relativa a null, viene generata un’eccezione NullPointerException.
• Le BlockingQueues vengono utilizzate per implementare applicazioni basate su Produttore/Consumatore.
• Le BlockingQueues sono thread-safe.
• Tutte le code disponibili nel pacchetto java.util sono code senza limiti, mentre le code disponibili nel pacchetto java.util.concurrent sono code con limiti.
• Tutte le code doppie non sono thread-safe.
• ConcurrentLinkedQueue è una coda thread-safe senza limiti basata su nodi collegati.
• Tutte le code supportano l’inserimento in coda e la rimozione in testa, eccetto le code doppie.
• Le code doppie sono code, ma supportano l’inserimento e la rimozione degli elementi sia alla fine che all’inizio.

Diagramma delle classi Java Queue

L’interfaccia Java Queue estende l’interfaccia Collection. L’interfaccia Collection estende l’interfaccia Iterable. Alcune delle classi di implementazione di Queue comunemente utilizzate sono LinkedList, PriorityQueue, ArrayBlockingQueue, DelayQueue, LinkedBlockingQueue, PriorityBlockingQueue, ecc… AbstractQueue fornisce un’implementazione di base dell’interfaccia Queue per ridurre lo sforzo nell’implementazione di Queue.

Metodi di Java Queue

In questa sezione discuteremo alcuni dei metodi utili e frequentemente utilizzati di Java Queue:

1. int size(): per ottenere il numero di elementi nell’insieme.
2. boolean isEmpty(): per verificare se l’insieme è vuoto o meno.
3. boolean contains(Object o): Restituisce true se questo Set contiene l’elemento specificato.
4. Iterator iterator(): Restituisce un iteratore sugli elementi di questo insieme. Gli elementi sono restituiti senza un ordine particolare.
5. boolean removeAll(Collection c): Rimuove da questo insieme tutti i suoi elementi contenuti nella collezione specificata (operazione facoltativa).
6. boolean retainAll(Collection c): Mantiene solo gli elementi in questo insieme che sono contenuti nella collezione specificata (operazione facoltativa).
7. void clear(): Rimuove tutti gli elementi dall’insieme.
8. E remove(): Retrieves and removes the head of this queue.
9. E poll(): Retrieves and removes the head of this queue, or returns null if this queue is empty.
10. E peek(): Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
11. boolean offer(E e): Inserisce l’elemento specificato in questa coda se è possibile farlo immediatamente senza violare le restrizioni di capacità.
12. E element(): Retrieves, but does not remove, the head of this queue.
13. boolean add(E e): Inserisce l’elemento specificato in questa coda se è possibile farlo immediatamente senza violare le restrizioni di capacità, restituendo true in caso di successo e lanciando un’IllegalStateException se al momento non è disponibile spazio.
14. Object[] toArray(): Restituisce un array contenente tutti gli elementi di questo insieme. Se questo insieme offre garanzie su quale ordine i suoi elementi vengono restituiti dal suo iteratore, questo metodo deve restituire gli elementi nello stesso ordine.

Java Queue Basics

Poiché Java Queue estende Java Collection, supporta anche tutte le operazioni dell’interfaccia Collection. Esploriamo alcune operazioni semplici nell’esempio seguente:

package com.journaldev.queue;
import java.util.*;

public class QueueExample {
   public static void main(String[] args) {
		
	Queue queue = new LinkedList<>();
	queue.add("one");
	queue.add("two");
	queue.add("three");
	queue.add("four");
	System.out.println(queue);
		
	queue.remove("three");
	System.out.println(queue);
	System.out.println("Queue Size: " + queue.size());
	System.out.println("Queue Contains element 'two' or not? : " + queue.contains("two"));

	// Per svuotare la coda
	queue.clear();
   }
}

Output:-

[one, two, three, four]
[one, two, four]
Queue Size: 3
Queue Contains element 'two' or not? : true

Array Java in Coda

Qui possiamo esplorare come convertire un array Java in coda usando il metodo “Collections.addAll()” con un semplice esempio.

import java.util.*;

public class ArrayToQueue {
    public static void main(String[] args) {
		
	String nums[] = {"one","two","three","four","five"};
	Queue<String> queue = new LinkedList<>();
	Collections.addAll(queue, nums);
	System.out.println(queue);
   }
}

Output:- Quando eseguiamo il programma sopra, otterremo il seguente output:

[one, two, three, four, five]

Coda Java in Array

Qui esploreremo come convertire una coda Java in un array Java usando “toArray()” con un semplice esempio.

import java.util.*;

public class QueueToArray {
   public static void main(String[] args) {
		
	Queue<String> queue = new LinkedList<>();
	queue.add("one");
	queue.add("two");
	queue.add("three");
	queue.add("four");
	queue.add("five");
		
	String strArray[] = queue.toArray(new String[queue.size()]);
	System.out.println(Arrays.toString(strArray)); 

   }
}

Output:- Quando eseguiamo il programma sopra, otterremo il seguente output:

[one, two, three, four, five]

Operazioni Comuni della Coda Java

La coda Java supporta tutte le operazioni supportate dall’interfaccia Collection e alcune operazioni in più. Supporta quasi tutte le operazioni in due forme.

• Un set di operazioni genera un’eccezione se l’operazione fallisce.
• L’altro set di operazioni restituisce un valore speciale se l’operazione fallisce.

La seguente tabella spiega brevemente tutte le operazioni comuni di coda.

Prenderemo in considerazione ogni operazione e le discuteremo dettagliatamente con alcuni esempi utili nelle sezioni successive.

Operazioni di inserimento della coda Java

In questa sezione, parleremo dell’operazione di inserimento della coda Java in dettaglio con alcuni esempi utili. Se questa operazione viene eseguita con successo, restituisce il valore “true”. Come sappiamo, la coda supporta l’operazione di inserimento in due forme:

• Coda.add(e):
  Genera un’eccezione se l’operazione fallisce.- Coda.offer(e):
  Restituisce un valore speciale se l’operazione fallisce.

NOTA:- Qui il valore speciale può essere sia “false” che “null”

Operazione add() della coda

L’operazione add() viene utilizzata per inserire un nuovo elemento nella coda. Se l’operazione di inserimento viene eseguita correttamente, restituisce il valore “true”. Altrimenti genera java.lang.IllegalStateException. Sviluppiamo un semplice esempio per dimostrare questa funzionalità.

import java.util.concurrent.*;

public class QueueAddOperation {
   public static void main(String[] args) {
		
	BlockingQueue<String> queue = new ArrayBlockingQueue<>(2);

	System.out.println(queue.add("one"));
	System.out.println(queue.add("two"));
	System.out.println(queue);
	System.out.println(queue.add("three"));
	System.out.println(queue);
   }
}

Output:- Quando eseguiamo il programma sopra, otteniamo il seguente output:

true
true
[one, two]
Exception in thread "main" java.lang.IllegalStateException: Queue full

Poiché la nostra coda è limitata a due elementi, quando proviamo ad aggiungere un terzo elemento utilizzando BlockingQueue.add(), viene generata un’eccezione come mostrato sopra.

Operazione di offerta della coda

L’operazione offer() viene utilizzata per inserire un nuovo elemento nella coda. Se l’operazione di inserimento viene eseguita con successo, restituisce il valore “true”. Altrimenti restituisce il valore “false”. Sviluppiamo un esempio semplice per dimostrare questa funzionalità.

import java.util.concurrent.*;

public class QueueOfferOperation {
   public static void main(String[] args) {
		
	BlockingQueue<String> queue = new ArrayBlockingQueue<>(2);

	System.out.println(queue.offer("one"));
	System.out.println(queue.offer("two"));
	System.out.println(queue);
	System.out.println(queue.offer("three"));
	System.out.println(queue);
   }
}

Output:- Quando eseguiamo il programma sopra, otteniamo il seguente output:

true
true
[one, two]
false
[one, two]

Poiché la nostra coda è limitata a due elementi, quando proviamo ad aggiungere un terzo elemento utilizzando l’operazione BlockingQueue.offer(), viene restituito il valore “false” come mostrato sopra.

Operazioni di eliminazione della coda Java

In questa sezione, discuteremo in dettaglio le operazioni di eliminazione della coda Java con alcuni esempi utili. Le operazioni di eliminazione restituiscono l’elemento in testa alla coda, se eseguite correttamente. Come sappiamo, la coda supporta l’operazione di eliminazione in due forme:

• Coda.remove():
  Genera un’eccezione se l’operazione non riesce.- Coda.poll():
  Restituisce un valore speciale se l’operazione non riesce.

NOTA:- Qui il valore speciale può essere “false” o “null”

Operazione di rimozione della coda

L’operazione remove() è utilizzata per eliminare un elemento dalla testa della coda. Se esegue con successo l’operazione di eliminazione, restituisce l’elemento in testa alla coda. Altrimenti, genera java.util.NoSuchElementException. Sviluppiamo un semplice esempio per dimostrare questa funzionalità.

import java.util.*;

public class QueueRemoveOperation 
{
   public static void main(String[] args) 
   {		
	Queue<String> queue = new LinkedList<>();
	queue.offer("one");
	queue.offer("two");		
	System.out.println(queue);		
	System.out.println(queue.remove());
	System.out.println(queue.remove());		
	System.out.println(queue.remove());		
   }
}

Output:- Quando eseguiamo il programma sopra, otteniamo il seguente output:

[one, two]
one
two
Exception in thread "main" java.util.NoSuchElementException

Poiché la nostra coda ha solo due elementi, quando proviamo a chiamare il metodo remove() per la terza volta, genera un’eccezione come mostrato sopra. NOTA:- Queue.remove(element) è utilizzato per eliminare un elemento specificato dalla coda. Se esegue con successo l’operazione di eliminazione, restituisce il valore “true”. Altrimenti restituisce il valore “false”.

Operazione poll() della coda

L’operazione poll() è utilizzata per eliminare un elemento dalla testa della coda. Se esegue con successo l’operazione di eliminazione, restituisce l’elemento in testa alla coda. Altrimenti restituisce il valore “null”. Sviluppiamo un semplice esempio per dimostrare questa funzionalità.

import java.util.*;

public class QueuePollOperation 
{
   public static void main(String[] args) 
   {		
	Queue<String> queue = new LinkedList<>();
	queue.offer("one");
	queue.offer("two");		
	System.out.println(queue);		
	System.out.println(queue.poll());
	System.out.println(queue.poll());		
	System.out.println(queue.poll());		
   }
}

Output:- Quando eseguiamo il programma sopra, otterremo il seguente output:

[one, two]
one
two
null

Poiché la nostra coda ha solo due elementi, quando cerchiamo di chiamare il metodo poll() per la terza volta, restituisce un valore nullo come mostrato sopra.

Operazioni di esame della coda Java

In questa sezione, discuteremo in dettaglio le operazioni di esame della coda Java con alcuni esempi utili. Se questa operazione viene eseguita con successo, restituisce l’elemento in testa alla coda senza rimuoverlo. Come sappiamo, la coda supporta l’operazione di esame in due forme:

• Queue.element():
  Solleva un’eccezione se l’operazione non riesce.- Queue.peek():
  Restituisce un valore speciale se l’operazione non riesce.

NOTA:- Qui il valore speciale può essere “false” o “null”

Operazione Queue element()

L’operazione element() viene utilizzata per recuperare un elemento dalla testa della coda, senza rimuoverlo. Se esegue con successo l’operazione di esame, restituisce l’elemento in testa alla coda. Altrimenti solleva java.util.NoSuchElementException. Sviluppiamo un semplice esempio per dimostrare questa funzionalità.

import java.util.*;

public class QueueElementOperation {
   public static void main(String[] args) {
		
	Queue<String> queue = new LinkedList<>();
	queue.add("one");
		
	System.out.println(queue.element());
	System.out.println(queue);
	queue.clear();
	System.out.println(queue.element());
   }
}

Output:- Quando eseguiamo il programma sopra, otterremo il seguente output:

one
[one]
Exception in thread "main" java.util.NoSuchElementException

Se proviamo a chiamare il metodo element() su una coda vuota, viene lanciata un’eccezione come mostrato sopra.

Operazione peek() della coda

L’operazione peek() viene utilizzata per recuperare un elemento dalla testa della coda, senza rimuoverlo. Se l’operazione di esame ha successo, restituisce l’elemento della testa della coda. In caso contrario, restituisce il valore null. Sviluppiamo un semplice esempio per dimostrare questa funzionalità.

import java.util.*;

public class QueuePeekOperation {
   public static void main(String[] args) {
		
	Queue<String> queue = new LinkedList<>();
	queue.add("one");
		
	System.out.println(queue.peek());
	System.out.println(queue);
	queue.clear();
	System.out.println(queue.peek());
   }
}

Output:- Quando eseguiamo il programma sopra, otteniamo l’output seguente:

one
[one]
null

Se proviamo a chiamare il metodo peek() su una coda vuota, restituisce il valore null, ma NON viene lanciata un’eccezione come mostrato sopra.

Categorie di Queue Java

In Java, possiamo trovare molte implementazioni di Queue. Possiamo categorizzarle ampiamente nei seguenti due tipi

• Code delimitate
• Code non delimitate

Le code a code son intention a code été à la code vitesse à laquelle il a été créé. Par exemple ArrayBlockingQueue (voir exemple précédent). Les files d’attente non bornées sont des files d’attente qui ne sont PAS bornées par une capacité, ce qui signifie que nous ne devrions pas fournir la taille de la file d’attente. Par exemple LinkedList (voir exemple précédent). Toutes les files d’attente disponibles dans le package java.util sont des files d’attente non bornées et les files d’attente disponibles dans le package java.util.concurrent sont des files d’attente bornées. D’une autre manière, nous pouvons les classer largement en deux types suivants:

• Files d’attente bloquantes
• Files d’attente non bloquantes

Toutes les files d’attente qui implémentent l’interface BlockingQueue sont des BlockingQueues et le reste sont des Files d’attente non bloquantes. Les BlockingQueues bloquent jusqu’à ce qu’elles aient terminé leur travail ou jusqu’à expiration du délai, mais les Non-BlockingQueues ne le font pas. Certaines files d’attente sont des Deques et certaines files d’attente sont des PriorityQueues.

Opérations de la BlockingQueue

En plus des deux formes d’opérations de la Queue, la BlockingQueue prend en charge deux autres formes comme indiqué ci-dessous.

Certaines opérations sont bloquées jusqu’à ce qu’elles aient terminé leur travail et d’autres sont bloquées jusqu’à expiration du délai. C’est tout pour un bref tour d’horizon sur la Queue en Java. J’espère que ces exemples de Queue en Java vous aideront à commencer la programmation avec des collections de Queue. Veuillez me laisser un commentaire si vous aimez mes tutoriels ou si vous avez des suggestions, des problèmes ou des erreurs de frappe. Merci.