Queue Data Structure Explained — How It Works, When to Use It, and Real Code

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

public class QueueConceptDemo {
    public static void main(String[] args) {

        // Java's built-in Queue interface, backed by a LinkedList.
        // Think of ticketQueue as the line at a cinema ticket counter.
        Queue<String> ticketQueue = new LinkedList<>();

        // ENQUEUE — people joining the back of the line
        ticketQueue.offer("Alice");   // Alice arrives first
        ticketQueue.offer("Bob");     // Bob arrives second
        ticketQueue.offer("Charlie"); // Charlie arrives third

        System.out.println("Queue after everyone joins: " + ticketQueue);
        // Output shows front-to-back order

        // PEEK — who is at the front WITHOUT removing them?
        String firstInLine = ticketQueue.peek();
        System.out.println("Who is at the front? " + firstInLine);
        System.out.println("Queue unchanged after peek: " + ticketQueue);

        // DEQUEUE — serving the person at the front
        String servedCustomer = ticketQueue.poll(); // removes and returns the front item
        System.out.println("Served: " + servedCustomer);
        System.out.println("Queue after serving: " + ticketQueue);

        // IS EMPTY — check before trying to serve
        System.out.println("Is the queue empty? " + ticketQueue.isEmpty());

        // Serve the remaining customers one by one
        while (!ticketQueue.isEmpty()) {
            System.out.println("Now serving: " + ticketQueue.poll());
        }

        System.out.println("Queue after all served: " + ticketQueue);
        System.out.println("Is the queue empty now? " + ticketQueue.isEmpty());
    }
}

public class CircularArrayQueue {

    private String[] storage;   // the array holding our queue items
    private int frontIndex;     // points to the item at the front of the queue
    private int rearIndex;      // points to the next empty slot at the back
    private int currentSize;    // how many items are currently in the queue
    private int capacity;       // maximum number of items this queue can hold

    // Constructor — set up an empty queue with a fixed capacity
    public CircularArrayQueue(int capacity) {
        this.capacity = capacity;
        this.storage = new String[capacity];
        this.frontIndex = 0;
        this.rearIndex = 0;
        this.currentSize = 0;
        // All slots start as null (empty)
    }

    // ENQUEUE — add an item to the back of the queue
    public boolean enqueue(String item) {
        if (isFull()) {
            System.out.println("Queue is full! Cannot add: " + item);
            return false; // overflow condition — refuse gracefully
        }
        storage[rearIndex] = item; // place item at the current rear slot
        // The magic of circular: wrap rearIndex back to 0 when it hits the end
        rearIndex = (rearIndex + 1) % capacity;
        currentSize++;
        return true;
    }

    // DEQUEUE — remove and return the item at the front
    public String dequeue() {
        if (isEmpty()) {
            System.out.println("Queue is empty! Nothing to dequeue.");
            return null; // underflow condition — refuse gracefully
        }
        String itemAtFront = storage[frontIndex]; // grab the front item
        storage[frontIndex] = null;               // clear the slot (good practice)
        // Circular wrap: move frontIndex forward, wrapping if necessary
        frontIndex = (frontIndex + 1) % capacity;
        currentSize--;
        return itemAtFront;
    }

    // PEEK — see the front item without removing it
    public String peek() {
        if (isEmpty()) {
            return null;
        }
        return storage[frontIndex];
    }

    // IS EMPTY — true if there are no items in the queue
    public boolean isEmpty() {
        return currentSize == 0;
    }

    // IS FULL — true if the queue has reached its capacity
    public boolean isFull() {
        return currentSize == capacity;
    }

    // Helper to visualise the queue state during testing
    public void printQueue() {
        if (isEmpty()) {
            System.out.println("Queue: [empty]");
            return;
        }
        System.out.print("Queue (front to back): ");
        for (int i = 0; i < currentSize; i++) {
            // Use modulo to traverse circularly from frontIndex
            System.out.print("[" + storage[(frontIndex + i) % capacity] + "] ");
        }
        System.out.println();
    }

    // ── MAIN — test drive our hand-built queue ──────────────────────────────
    public static void main(String[] args) {

        CircularArrayQueue airportSecurityLine = new CircularArrayQueue(4);

        // Passengers joining the security line
        airportSecurityLine.enqueue("Passenger: Diana");
        airportSecurityLine.enqueue("Passenger: Edward");
        airportSecurityLine.enqueue("Passenger: Fatima");
        airportSecurityLine.enqueue("Passenger: George");
        airportSecurityLine.printQueue();

        // Try to add one more — queue is full
        airportSecurityLine.enqueue("Passenger: Hannah");

        // First two passengers go through security
        System.out.println("Cleared security: " + airportSecurityLine.dequeue());
        System.out.println("Cleared security: " + airportSecurityLine.dequeue());
        airportSecurityLine.printQueue();

        // Now there's room — Hannah can join
        airportSecurityLine.enqueue("Passenger: Hannah");
        System.out.println("Front of line right now: " + airportSecurityLine.peek());
        airportSecurityLine.printQueue();

        // Clear everyone out
        while (!airportSecurityLine.isEmpty()) {
            System.out.println("Cleared security: " + airportSecurityLine.dequeue());
        }

        // Try to dequeue from empty queue
        airportSecurityLine.dequeue();
    }
}

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

public class PrintSpoolerSimulation {

    // Simulates a printer that can only print one document at a time
    static void simulatePrinter(Queue<String> printQueue) {
        System.out.println("=== Printer starting up ===");

        // Keep printing as long as there are documents waiting
        while (!printQueue.isEmpty()) {
            // poll() retrieves AND removes the front document
            String currentDocument = printQueue.poll();
            System.out.println("Printing: " + currentDocument);

            // Simulate the time it takes to print (just a message here)
            System.out.println("  → " + currentDocument + " complete. Next!");
        }

        System.out.println("=== Print queue empty. Printer idle. ===");
    }

    public static void main(String[] args) {

        // The office print queue — documents arrive in this order
        Queue<String> officePrintQueue = new LinkedList<>();

        // Three people send documents at roughly the same time
        officePrintQueue.offer("Alice's Expense Report.pdf");     // sent first
        officePrintQueue.offer("Bob's Project Proposal.docx");    // sent second
        officePrintQueue.offer("Charlie's Meeting Notes.txt");    // sent third

        System.out.println("Documents queued up: " + officePrintQueue);
        System.out.println("Total documents waiting: " + officePrintQueue.size());
        System.out.println();

        // Hand the queue off to the printer
        simulatePrinter(officePrintQueue);

        // Alice sends another document after the queue cleared
        System.out.println();
        officePrintQueue.offer("Alice's Quarterly Review.pdf");
        System.out.println("New document arrived: " + officePrintQueue.peek());
        simulatePrinter(officePrintQueue);
    }
}