队列的实现

队列是一种先入先出（FIFO）的数据结构，可以使用数组或者链表实现，入队和出队的时间复杂度为O(1)。

队列的应用在于重演历史。多线程中争夺公平锁的等待队列，按照优先级出队的优先队列等。

循环队列的实现

为了维持队列容量的恒定，可以用数组来实现循环队列，此时队列的容量为数组容量-1。

public class MyQueue {
    //队列使用数组存储，队列的容量为数组容量-1
    private int[] array;
    //队头下标
    private int front;
    //队尾下标，指向最后一个入队元素的下一个位置
    private int rear;

    public MyQueue(int capacity) {
        array = new int[capacity];
    }

    public static void main(String[] args) throws Exception {
        MyQueue myQueue = new MyQueue(5);
        myQueue.enQueue(1);
        myQueue.enQueue(2);
        myQueue.enQueue(3);
        myQueue.enQueue(4);
        myQueue.print();

        System.out.println(myQueue.deQueue());
        System.out.println(myQueue.deQueue());
        System.out.println(myQueue.deQueue());
        System.out.println(myQueue.deQueue());
    }

    public void enQueue(int element) throws Exception {
        if ((rear + 1) % array.length == front) {
            throw new Exception("队列已满");
        }

        array[rear] = element;
        rear = (rear + 1) % array.length;
    }

    public int deQueue() throws Exception {
        if (front == rear) {
            throw new Exception("队列已空");
        }
        int element = array[front];
        front = (front + 1) % array.length;
        return element;
    }

    public void print() {
        //从front到rear，循环打印
        for (int i = front; i != rear; i = (i + 1) % array.length) {
            System.out.print(array[i] + " ");
        }

        System.out.println();
    }
}

队列初始化（入队）：1 2 3 4 
出队：1
出队：2
出队：3
出队：4