Coda in Java

Una coda (in Java nei nostri esempi) è un tipo di struttura dati che segue la regola “FIFO” (first in, first out), il che significa che l’elemento inserito per primo sarà il primo ad essere rimosso.

Coda di tipi primitivi in Java

public class Coda {
    private int[] elementi;
    private int primo;
    private int ultimo;
    private int numElementi;
    private int capacità;

    public Coda(int capacità) {
        this.capacità = capacità;
        elementi = new int[capacità];
        primo = 0;
        ultimo = -1;
        numElementi = 0;
    }

    // Aggiunge un elemento alla coda
    public void enqueue(int elemento) {
        if (ultimo == capacità - 1) {
            ultimo = -1;
        }
        elementi[++ultimo] = elemento;
        numElementi++;
    }

    // Rimuove un elemento dalla coda
    public int dequeue() {
        int elemento = elementi[primo++];
        if (primo == capacità) {
            primo = 0;
        }
        numElementi--;
        return elemento;
    }

    // Restituisce il numero di elementi nella coda
    public int size() {
        return numElementi;
    }
}

In questa implementazione, abbiamo un array elementi che memorizza i valori della coda. Gli elementi vengono inseriti all’ultimo indice e rimossi dall’indice più piccolo. La capacità della coda viene definita durante la creazione dell’oggetto.

Il metodo enqueue aggiunge un elemento alla coda, mentre il metodo dequeue rimuove l’elemento dalla coda. Il metodo size restituisce il numero di elementi nella coda.

Coda di oggetti in Java

Ecco un semplice esempio di coda di oggetti implementata da zero in Java:

class Queue<T> {

  private class Node {
    T item;
    Node next;

    Node(T item) {
      this.item = item;
      this.next = null;
    }
  }

  private Node front, rear;
  private int size;

  public Queue() {
    front = rear = null;
    size = 0;
  }

  // Verifica se la coda è vuota
  public boolean isEmpty() {
    return (front == null);
  }

  // Ritorna la dimensione della coda
  public int getSize() {
    return size;
  }

  // Aggiungi un elemento alla coda
  public void enqueue(T item) {
    Node temp = new Node(item);
    if (rear == null) {
      front = rear = temp;
      return;
    }
    rear.next = temp;
    rear = temp;
    size++;
  }

  // Rimuovi un elemento dalla coda
  public T dequeue() {
    if (front == null) {
      return null;
    }
    T item = front.item;
    front = front.next;
    if (front == null) {
      rear = null;
    }
    size--;
    return item;
  }
}

In questo esempio, abbiamo creato una classe generica Queue che contiene una classe interna Node per rappresentare i nodi della coda.

La classe Queue contiene una serie di metodi, tra cui enqueue per inserire un elemento nella coda, dequeue per rimuovere un elemento dalla coda, isEmpty per verificare se la coda è vuota e getSize per ottenere la dimensione della coda.

Questo esempio mostra come è possibile creare una coda di oggetti utilizzando la struttura a lista collegata.

Coda di oggetti utilizzando LinkedList

In Java, la classe java.util.Queue rappresenta un’interfaccia per le code. Alcune implementazioni concrete dell’interfaccia Queue sono ArrayDeque e LinkedList.

Ecco un esempio di come si potrebbe utilizzare una coda in Java:

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        
        // aggiungi elementi alla coda
        queue.add(1);
        queue.add(2);
        queue.add(3);
        
        // visualizza gli elementi nella coda
        System.out.println(queue); // output: [1, 2, 3]
        
        // rimuovi l'elemento in cima alla coda
        int removedElement = queue.remove();
        System.out.println("Removed element: " + removedElement); // output: Removed element: 1
        
        // visualizza gli elementi rimanenti nella coda
        System.out.println(queue); // output: [2, 3]
    }
}

In questo esempio, abbiamo utilizzato la classe LinkedList per creare una coda. Abbiamo quindi aggiunto elementi alla coda utilizzando il metodo add(), e rimosso l’elemento dall’inizio della coda utilizzando il metodo remove(). Abbiamo poi stampato i contenuti della coda per verificare che l’elemento sia stato rimosso correttamente.

Casi di utilizzo della coda

Ecco alcuni esempi di utilizzo della coda in ambito tecnologico:

  1. Sistemi di pianificazione delle attività: Quando programmi un compito da eseguire sul tuo computer, viene inserito in una coda e viene eseguito in ordine cronologico rispetto ad altri compiti già presenti nella coda.
  2. Sistemi di messaggistica: Quando invii un messaggio su un’app di messaggistica, il messaggio viene inserito in una coda e viene inviato ai destinatari in ordine cronologico rispetto ad altri messaggi già presenti nella coda.
  3. Sistemi di prenotazione: Quando prenoti un volo o una camera d’albergo, la tua prenotazione viene inserita in una coda e viene elaborata in ordine cronologico rispetto ad altre prenotazioni già presenti nella coda.
  4. Sistemi di transazione finanziaria: Quando effettui una transazione finanziaria, la transazione viene inserita in una coda e viene elaborata in ordine cronologico rispetto ad altre transazioni già presenti nella coda.

Ecco alcuni esempi di utilizzo della coda in ambito non tecnologico:

  1. Sistema di stampa: Quando invii un documento per la stampa, viene inserito in una coda e viene stampato in ordine cronologico rispetto ad altri documenti già presenti nella coda.
  2. Servizio clienti: Quando chiami un servizio clienti, vieni messo in coda per parlare con un operatore. Gli operatori gestiscono le chiamate in ordine cronologico, ovvero la prima persona che ha chiamato viene messa in coda prima degli altri.
  3. Sistema di coda per attrazioni: Quando ti rechi in un parco divertimenti, puoi unirti alla coda per un’attrazione specifica. Le persone in coda vengono servite in ordine cronologico, ovvero la prima persona che si è unita alla coda viene servita prima degli altri.
  4. Codice di emergenza: Quando segnali un’emergenza, vieni messo in coda per parlare con un operatore. Gli operatori gestiscono le chiamate in ordine di priorità, ovvero le chiamate per le emergenze più gravi vengono gestite prima degli altri.

Questi sono solo alcuni esempi di utilizzo della coda in ambito non tecnologico. La coda è un concetto molto versatile che viene utilizzato in molti altri contesti, sia in ambito tecnologico che non tecnologico.

Pila in Java

Pubblicato da Carlo Contardi

Carlo Contardi, docente di informatica e sviluppatore Full Stack, condivide la sua passione per la programmazione e l’informatica attraverso il suo blog Space Coding. Offre preziosi consigli e soluzioni pratiche a chi vuole imparare a programmare o migliorare le proprie abilità. 🚀👨‍💻

Translate »