circular array queue

// Circular Array queue implementation using a linear array
public class CircularArrayQueue {

    // Array-based fields
    final int[] arr;           // Array to store elements
    int front;                 // Index of front element
    int rear;                  // Index of rear element
    final int capacity;        // Maximum queue capacity
    int size;                  // Current number of elements

    // Constructor
    public CircularArrayQueue(int capacity) {
        this.capacity = capacity;
        arr = new int[capacity];
        front = 0;
        rear = -1;
        size = 0;
    }

    // Insert an item into the queue
    public void enqueue(int item) {
        if (isFull()) {
            System.out.println("Queue is full. Cannot enqueue.");
            return;
        }
        rear = (rear + 1) % capacity; // Wrap around when needed
        arr[rear] = item;
        size++;
    }

    // Remove an item from the queue
    public int dequeue() {
        if (isEmpty()) {
            System.out.println("Queue is empty. Cannot dequeue.");
            return Integer.MIN_VALUE;
        }
        int item = arr[front];
        front = (front + 1) % capacity; // Wrap around when needed
        size--;
        return item;
    }

    // Get the front item without removing it
    public int peek() {
        if (isEmpty()) {
            System.out.println("Queue is empty. No peek value.");
            return Integer.MIN_VALUE;
        }
        return arr[front];
    }

    // Check if the queue is full
    public boolean isFull() {
        return size == capacity;
    }

    // Check if the queue is empty
    public boolean isEmpty() {
        return size == 0;
    }

    // Display internal state for analysis and comparison
    public void printState(String stepTitle, String enqueueItems, Integer dequeued) {
        System.out.println("------------" + stepTitle + "---------------");
        if (enqueueItems != null) {
            System.out.println("Enqueue: " + enqueueItems + ";");
        }
        if (dequeued != null) {
            System.out.println("Dequeued: " + dequeued + ";");
        }
        System.out.println("Front index: " + front);
        System.out.println("Rear index: " + rear);
        System.out.println("Peek value: " + (isEmpty() ? "N/A" : peek()));
        System.out.println("Current size: " + size);

        System.out.print("Array content: ");
        for (int i = 0; i < capacity; i++) {
            System.out.print(arr[i] + " ");
        }

        System.out.print("\nVisible queue: ");
        int count = 0, idx = front;
        while (count < size) {
            System.out.print(arr[idx] + " ");
            idx = (idx + 1) % capacity;
            count++;
        }
        System.out.println("\n");
    }

    // Demonstration steps
    public static void main(String[] args) {
        CircularArrayQueue queue = new CircularArrayQueue(5);

        // Step 1: Enqueue 4 items
        queue.enqueue(10);
        queue.enqueue(20);
        queue.enqueue(30);
        queue.enqueue(40);
        queue.printState("Step 1 : enqueue", "10, 20, 30, 40", null);

        // Step 2: Dequeue 1 item
        int removed = queue.dequeue();
        queue.printState("Step 2 : dequeue", null, removed);

        // Step 3: Enqueue item to reused position
        queue.enqueue(50);
        queue.printState("Step 3 : enqueue", "50", null);

        // Step 4: Wrap-around insert
        queue.enqueue(60);
        queue.printState("Step 4 : enqueue", "60", null);
    }
}