基于动态循环数组实现队列（JAVA）

简单循环数组实现队列的局限性

用于实现队列的数组的最大空间必须预先声明并且不可改变，试图对于一个满队列执行入队操作和队一个空队列做出队列操作都会队列的相关异常

基于动态数组实现队列

/**
 * 基于动态数组实现队列
 */
public class DynArrayQueue {
    /**
     * 队列头指针
     */
    private int front;
    /**
     * 队列尾指针
     */
    private int rear;
    /**
     * 队列容量
     */
    private int capacity;
    /**
     * 容器
     */
    private int[] array;

    /**
     * 私有化构造器，初始容量为1
     */
    private DynArrayQueue() {
        capacity = 1;
        front = -1;
        rear = -1;
        array = new int[1];
    }

    public static DynArrayQueue createDynArrayQueue() {
        return new DynArrayQueue();
    }

    /**
     * 判空操作
     *
     * @return
     */
    public boolean isEmpty() {
        return front == -1;
    }

    /**
     * 满队列操作
     *
     * @return
     */
    public boolean isFull() {
        return (rear + 1) % capacity == front;
    }

    /**
     * 获取队列容量
     *
     * @return
     */
    public int getQueueSize() {
        if (front == -1) {
            return 0;
        }
        int size = (capacity - front + rear + 1) % capacity;
        if (size == 0) {
            return capacity;
        } else {
            return size;
        }
    }

    /**
     * 容器数组扩容
     */
    private void resizeQueue() {
        int initCapacity = this.capacity;
        capacity *= 2;
        int[] oldArray = this.array;
        array = new int[capacity];
        System.arraycopy(oldArray, 0, array, 0, oldArray.length);
        if (rear < front) {
            if (front >= 0) System.arraycopy(this.array, 0, array, 0 + initCapacity, front);
            rear = rear + initCapacity;
        }
    }

    /**
     * 入队操作
     *
     * @param data
     */
    public void enQueue(int data) {
        if (isFull()) {
            resizeQueue();
        }
        rear = (rear + 1) % capacity;
        array[rear] = data;
        if (front == -1) {
            front = rear;
        }
    }

    /**
     * 出栈操作
     *
     * @return
     */
    public int deQueue() {
        Integer data = null;
        if (isEmpty()) {
            throw new RuntimeException("Queue is Empty!");
        } else {
            data = array[front];
            if (front == rear) {
                front = rear = -1;
            }
        }
        return data;
    }
}