java代码如何实现循环队列避免假溢出 java代码循环队列的基础编写教程​

public class CircularQueue {
    private int[] queue;
    private int front;
    private int rear;
    private int capacity;

    public CircularQueue(int capacity) {
        this.capacity = capacity;
        this.queue = new int[capacity];
        this.front = 0;
        this.rear = 0; // 初始时，front 和 rear 指向同一个位置
    }

    public boolean isFull() {
        return (rear + 1) % capacity == front;
    }

    public boolean isEmpty() {
        return front == rear;
    }

    public boolean enqueue(int data) {
        if (isFull()) {
            System.out.println("Queue is full");
            return false;
        }
        queue[rear] = data;
        rear = (rear + 1) % capacity;
        return true;
    }

    public int dequeue() {
        if (isEmpty()) {
            System.out.println("Queue is empty");
            return -1; // 或者抛出异常
        }
        int data = queue[front];
        front = (front + 1) % capacity;
        return data;
    }

    public void display() {
        if (isEmpty()) {
            System.out.println("Queue is empty");
            return;
        }
        System.out.print("Queue elements: ");
        int i = front;
        while (i != rear) {
            System.out.print(queue[i] + " ");
            i = (i + 1) % capacity;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        CircularQueue q = new CircularQueue(5);
        q.enqueue(1);
        q.enqueue(2);
        q.enqueue(3);
        q.enqueue(4);
        q.display(); // Output: Queue elements: 1 2 3 4
        System.out.println("Dequeued element: " + q.dequeue()); // Output: Dequeued element: 1
        q.enqueue(5);
        q.display(); // Output: Queue elements: 2 3 4 5
        q.enqueue(6); // Output: Queue is full
    }
}

CircularQueue(int capacity)

capacity

capacity - 1

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConcurrentCircularQueue {
    private int[] queue;
    private int front;
    private int rear;
    private int capacity;
    private Lock lock = new ReentrantLock();

    public ConcurrentCircularQueue(int capacity) {
        this.capacity = capacity;
        this.queue = new int[capacity];
        this.front = 0;
        this.rear = 0;
    }

    public boolean enqueue(int data) {
        lock.lock();
        try {
            if (isFull()) {
                System.out.println("Queue is full");
                return false;
            }
            queue[rear] = data;
            rear = (rear + 1) % capacity;
            return true;
        } finally {
            lock.unlock();
        }
    }

    public int dequeue() {
        lock.lock();
        try {
            if (isEmpty()) {
                System.out.println("Queue is empty");
                return -1;
            }
            int data = queue[front];
            front = (front + 1) % capacity;
            return data;
        } finally {
            lock.unlock();
        }
    }

    private boolean isFull() {
        return (rear + 1) % capacity == front;
    }

    private boolean isEmpty() {
        return front == rear;
    }
}