Java Stack and Queue Explained — How, When, and Why to Use Each

import java.util.ArrayDeque;
import java.util.Deque;

/**
 * Simulates a browser's Back button using a Stack.
 * Each time you visit a page, push its URL onto the history stack.
 * Hitting Back pops the current page and returns you to the previous one.
 */
public class BrowserHistory {

    public static void main(String[] args) {

        // ArrayDeque used as a Stack — modern, fast, no legacy baggage
        Deque<String> historyStack = new ArrayDeque<>();

        // User navigates to three pages
        historyStack.push("https://google.com");
        historyStack.push("https://thecodeforge.io");
        historyStack.push("https://thecodeforge.io/java-collections");

        System.out.println("Current page: " + historyStack.peek()); // view top without removing

        // User clicks Back — removes the current page from the top
        String leavingPage = historyStack.pop();
        System.out.println("Left: " + leavingPage);
        System.out.println("Now on: " + historyStack.peek());

        // User clicks Back again
        historyStack.pop();
        System.out.println("Now on: " + historyStack.peek());

        // Safe empty-check before popping — never pop blindly
        if (!historyStack.isEmpty()) {
            historyStack.pop();
        }

        // Stack is now empty — peek would return null on ArrayDeque (not throw)
        System.out.println("History empty: " + historyStack.isEmpty());
        System.out.println("Peek on empty ArrayDeque: " + historyStack.peek()); // returns null
    }
}

import java.util.ArrayDeque;
import java.util.Queue;

/**
 * A simple task scheduler that processes support tickets in the order they arrive.
 * First ticket submitted = first ticket resolved. Classic FIFO.
 */
public class TaskScheduler {

    // Represents a single unit of work
    record SupportTicket(int id, String description) {
        @Override
        public String toString() {
            return "Ticket #" + id + " [" + description + "]";
        }
    }

    public static void main(String[] args) {

        // ArrayDeque as a Queue — faster than LinkedList for most use cases
        Queue<SupportTicket> ticketQueue = new ArrayDeque<>();

        // Customers submit support tickets at different times
        ticketQueue.offer(new SupportTicket(1001, "Login page not loading"));
        ticketQueue.offer(new SupportTicket(1002, "Payment fails at checkout"));
        ticketQueue.offer(new SupportTicket(1003, "Profile photo won't upload"));

        System.out.println("Tickets waiting: " + ticketQueue.size());
        System.out.println("Next to process: " + ticketQueue.peek()); // look without removing

        System.out.println("\n--- Processing tickets in order ---");

        // Process every ticket in FIFO order — first submitted, first resolved
        while (!ticketQueue.isEmpty()) {
            SupportTicket current = ticketQueue.poll(); // removes head, returns null if empty (safe)
            System.out.println("Resolving: " + current);
        }

        // poll() on an empty queue returns null — no exception
        SupportTicket ghost = ticketQueue.poll();
        System.out.println("\nPolled empty queue: " + ghost); // null, not an exception
    }
}

import java.util.ArrayDeque;
import java.util.Deque;

/**
 * A text editor with Undo and Redo — both implemented with ArrayDeque.
 * Undo stack: tracks actions in reverse (most recent on top).
 * Redo stack: stores undone actions so they can be replayed.
 */
public class UndoRedoEditor {

    public static void main(String[] args) {

        // undoStack holds every action the user has performed, most recent on top
        Deque<String> undoStack = new ArrayDeque<>();
        // redoStack holds actions the user has undone, so they can be redone
        Deque<String> redoStack = new ArrayDeque<>();

        // User types three things
        performAction(undoStack, redoStack, "Typed: Hello");
        performAction(undoStack, redoStack, "Typed: World");
        performAction(undoStack, redoStack, "Bold: World");

        System.out.println("=== Current undo history (top = most recent) ===");
        System.out.println(undoStack);

        // User hits Ctrl+Z twice
        System.out.println("\n--- Undo ---");
        undo(undoStack, redoStack);
        undo(undoStack, redoStack);

        // User hits Ctrl+Y once
        System.out.println("\n--- Redo ---");
        redo(undoStack, redoStack);

        System.out.println("\n=== Final undo stack ===");
        System.out.println(undoStack);
        System.out.println("=== Final redo stack ===");
        System.out.println(redoStack);
    }

    static void performAction(Deque<String> undoStack, Deque<String> redoStack, String action) {
        undoStack.push(action);   // push to top of undo stack
        redoStack.clear();        // any new action wipes the redo history (just like real editors)
        System.out.println("Did: " + action);
    }

    static void undo(Deque<String> undoStack, Deque<String> redoStack) {
        if (undoStack.isEmpty()) {
            System.out.println("Nothing to undo.");
            return;
        }
        String lastAction = undoStack.pop();   // remove from top of undo stack
        redoStack.push(lastAction);            // move it to redo stack
        System.out.println("Undid: " + lastAction);
    }

    static void redo(Deque<String> undoStack, Deque<String> redoStack) {
        if (redoStack.isEmpty()) {
            System.out.println("Nothing to redo.");
            return;
        }
        String redonAction = redoStack.pop();  // take from top of redo stack
        undoStack.push(redonAction);           // put back on undo stack
        System.out.println("Redid: " + redonAction);
    }
}