Una coda è un altro tipo di struttura dati lineare utilizzata per memorizzare elementi proprio come qualsiasi altra struttura dati ma in un modo particolare. In parole semplici, possiamo dire che la coda è un tipo di struttura dati nel linguaggio di programmazione Java che memorizza elementi dello stesso tipo. I componenti in una coda vengono archiviati secondo un comportamento FIFO (First In, First Out). Ci sono due estremità nella raccolta code, ovvero anteriore e posteriore. La coda ha due estremità: anteriore e posteriore.

La figura seguente descrive perfettamente la proprietà FIFO (First In, First Out) della coda Java.

Come spiegato nell'immagine precedente, possiamo vedere che la coda è una struttura di dati lineare con due terminali, ovvero inizio (anteriore) e fine (posteriore). I componenti vengono aggiunti all'interno della coda dall'estremità posteriore della coda e i componenti vengono estratti dall'estremità anteriore della coda.

La coda è un'interfaccia nel file Giava che appartiene al pacchetto Java.util. Estende inoltre l'interfaccia della raccolta.

tostring java

Di seguito è mostrata la rappresentazione generica dell'interfaccia Java Queue:

 public interface Queue extends Collection 

Come abbiamo discusso in precedenza, la coda è un'interfaccia, quindi possiamo anche dire che la coda non può essere istanziata perché le interfacce non possono essere istanziate. Se un utente desidera implementare la funzionalità dell'interfaccia Queue in Java, è obbligatorio disporre di alcune classi solide che implementano l'interfaccia Queue.

Nel linguaggio di programmazione Java, esistono due classi diverse utilizzate per implementare l'interfaccia Queue. Queste classi sono:

• Lista collegata
• PriorityQueue

Caratteristiche della coda Java

La coda Java può essere considerata una delle strutture dati più importanti nel mondo della programmazione. Java Queue è attraente per le sue proprietà. Le proprietà significative della struttura dati Java Queue sono fornite come segue:

• Java Queue obbedisce alla modalità FIFO (First In, First Out). Indica che gli elementi vengono inseriti in coda alla fine ed eliminati dal fronte.
• L'interfaccia Java Queue fornisce tutte le regole e i processi dell'interfaccia Collection come inclusione, eliminazione, ecc.
• Esistono due classi diverse utilizzate per implementare l'interfaccia Queue. Queste classi sono LinkedList e PriorityQueue.
• Oltre a queste due, esiste una classe, Array Blocking Queue, utilizzata per implementare l'interfaccia Queue.
• Esistono due tipi di code, code illimitate e code limitate. Le code che fanno parte del pacchetto java.util sono note come code illimitate e le code limitate sono le code presenti nel pacchetto java.util.concurrent.
• Anche la Deque o (coda a doppia estremità) è un tipo di coda che comporta l'inclusione e la cancellazione di elementi da entrambe le estremità.
• La deque è anche considerata thread-safe.
• Le code di blocco sono anche uno dei tipi di code thread-safe. Le code di blocco vengono utilizzate per implementare le query produttore-consumatore.
• Le code di blocco non supportano elementi null. Nelle code di blocco, se viene provato un lavoro simile ai valori null, viene lanciata anche la NullPointerException.

Implementazione della coda

Classi utilizzate nell'implementazione di Queue

Le classi utilizzate per implementare le funzionalità della coda sono le seguenti:

• ArrayDeque
• Lista collegata
• PriorityQueue

Interfacce utilizzate nell'implementazione di Queue

Le interfacce Java vengono utilizzate anche nell'implementazione della coda Java. Le interfacce utilizzate per implementare le funzionalità della coda sono le seguenti:

• Riguardo a cosa
• Blocco della coda
• Blocco della decodifica

Metodi di classe della coda Java

Nella coda Java sono presenti molti metodi utilizzati molto comunemente. L'interfaccia Queue promuove diversi metodi come insert, delete, peek, ecc. Alcune operazioni della coda Java sollevano un'eccezione mentre alcune di queste operazioni restituiscono un valore particolare quando il programma è completato.

Nota: in Java SE 8, non vengono apportate modifiche alla raccolta code Java. Questi metodi definiti di seguito verranno ulteriormente elaborati nelle versioni successive del linguaggio di programmazione Java. Ad esempio, Java SE 9.

Di seguito sono definiti i diversi metodi della coda Java:

Implementazione dell'array di code Java

L'implementazione della coda non è così semplice come l'implementazione dello stack.

Per implementare la coda utilizzando gli array, dichiariamo prima un array che contiene n numero di elementi.

Quindi definiamo le seguenti operazioni da eseguire in questa coda.

1) Accodamento: Un'operazione per inserire un elemento nella coda è Enqueue (funzione coda Enqueue nel programma). Per inserire un elemento nella parte posteriore, dobbiamo prima verificare se la coda è piena. Se è pieno, non possiamo inserire l'elemento. Se posteriore

2) Coda: L'operazione per eliminare un elemento dalla coda è Dequeue (funzione coda Dequeue nel programma). Per prima cosa controlliamo se la coda è vuota. Affinché l'operazione di rimozione dalla coda funzioni, deve essere presente almeno un elemento nella coda.

3) Davanti: Questo metodo restituisce la parte anteriore della coda.

4) Visualizzazione: Questo metodo attraversa la coda e visualizza gli elementi della coda.

Programma coda Java

Il seguente programma Java dimostra l'implementazione di Queue.

QueueArrayImplementation.java

 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
&apos;); return; } // shift elements to the right by one place uptil rear else { for (int i = 0; i <rear 0 4 - 1; i++) { queue[i]="queue[i" + 1]; } set queue[rear] to if (rear < capacity) decrement rear rear--; return; print queue elements static void queuedisplay() int i; (front="=" rear) system.out.printf('queue is empty
'); traverse front and for (i="front;" i rear; system.out.printf(' %d , ', queue[i]); of queuefront() system.out.printf('
front element the queue: %d', queue[front]); public class queuearrayimplementation main(string[] args) create a capacity q="new" queue(4); system.out.println('initial queue:'); q.queuedisplay(); inserting in q.queueenqueue(10); q.queueenqueue(30); q.queueenqueue(50); q.queueenqueue(70); system.out.println('queue after enqueue operation:'); q.queuefront(); insert q.queueenqueue(90); q.queuedequeue(); system.out.printf('
queue two dequeue operations:'); pre> <p> <strong>Output:</strong> </p> <pre> Initial Queue: Queue is Empty Queue after Enqueue Operation: 10 , 30 , 50 , 70 , Front Element of the queue: 10 Queue is full 10 , 30 , 50 , 70 , Queue after two dequeue operations: 50 , 70 , Front Element of the queue: 50 </pre> <h2>Java Queue Linked List Implementation</h2> <p>As we have implemented the Queue data structure using Arrays in the above program, we can also implement the Queue using Linked List.</p> <p>We will implement the same methods enqueue, dequeue, front, and display in this program. The difference is that we will be using the Linked List data structure instead of Array.</p> <p>The below program demonstrates the Linked List implementation of Queue in Java.</p> <p> <strong>QueueLLImplementation.java</strong> </p> <pre> 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 &amp; 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(&apos;Element &apos; + data+ &apos; removed from the queue&apos;); 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(&apos;Element &apos; + data+ &apos; added to the queue&apos;); } //print front and rear of the queue public void print_frontRear() { System.out.println(&apos;Front of the queue:&apos; + front.data + &apos; Rear of the queue:&apos; + rear.data); } } class QueueLLImplementation{ 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(); } } </pre> <p> <strong>Output:</strong> </p> <pre> Element 6 added to the queue Element 3 added to the queue Front of the queue:6 Rear of the queue:3 Element 12 added to the queue Element 24 added to the queue Element 6 removed from the queue Element 3 removed from the queue Element 9 added to the queue Front of the queue:12 Rear of the queue:9 </pre> <hr></rear>

Implementazione dell'elenco collegato di code Java

Poiché abbiamo implementato la struttura dei dati della coda utilizzando gli array nel programma sopra, possiamo anche implementare la coda utilizzando la lista collegata.

Implementeremo gli stessi metodi di accodamento, rimozione dalla coda, anteriore e visualizzazione in questo programma. La differenza è che utilizzeremo la struttura dati Linked List invece di Array.

Il programma seguente dimostra l'implementazione dell'elenco collegato di Queue in Java.

QueueLLImplementation.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 QueueLLImplementation{ 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(); } } 

Produzione:

 Element 6 added to the queue Element 3 added to the queue Front of the queue:6 Rear of the queue:3 Element 12 added to the queue Element 24 added to the queue Element 6 removed from the queue Element 3 removed from the queue Element 9 added to the queue Front of the queue:12 Rear of the queue:9