手动实现循环队列【练习】

package circle;

/**
 * @author 长静有希
 * @description 循环队列
 * @date 2021-12-03 13:57
 */
public class CircleQueue<E> {

    // 用于存储对头元素下标
    private int front;

    private int size;

    // 用于存储数据
    private E[] elements;

    // 初始容量
    private static final int DEFAULT_CAPACITY = 10;

	/** 
     * 可提供大小但没必要，不影响使用
     **/
    public CircleQueue() {
        elements = (E[]) new Object[DEFAULT_CAPACITY];
    }

	/** 
     * 判空
     * @return: boolean
     **/
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 入队
     * @return: void
     **/
    public void enQueue(E element) {

        // 动态扩容判断
        ensureCapacity(size + 1);
        elements[index(size)] = element;
        size++;
    }

    /**
     * 出队
     * @return: E
     **/
    public E deQueue() {
        // 需要出队，所有需要获取队头元素
        E frontElement = elements[front];

        // 出队完赋值为空
        elements[front] = null;

        // 队头指向下一个元素
        // 因为当数组队头指向后面，而队尾在前面的时候，直接front++ 会越界，
        // 所有需要对数组长度进行取模
        front = index(1);

        size--;
        return frontElement;
    }

    /**
     * 获取对头元素
     * @return: E
     **/
    public E front() {
        return elements[front];
    }

    /**
     * 获取front真实指向位置
     * @return: int
     **/
    private int index(int index) {

		// 取模运算符效率低
		// return (front + index) % elements.length;

        // 优化写法
        index += front;

        // 因为index + front 的大小并不会大于两倍的elements.length
        return index - (index >= elements.length ? elements.length : 0);
    }





    /**
     * 动态扩容
     * 需要保证要有capacity大小的容量
     * @return: void
     **/
    private void ensureCapacity(int capacity) {
        // 旧的容量
        int oldCapacity = elements.length;
        // 如果旧的容量大于或等于需要的容量，则不需要扩容
        if (oldCapacity >= capacity) return;

        // 新的容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 存储元素
        E[] newElements = (E[]) new Object[newCapacity];

        for (int i = 0; i < size; i++) {
            newElements[i] = elements[index(i)];
        }
        elements = newElements;

        // 创建了新数组，队头重新指向 0
        front = 0;
    }



    @Override
    public String toString() {

        StringBuilder string = new StringBuilder();

        string.append("capacity=").append(elements.length)
                .append(" size= ").append(size)
                .append(" front= ").append(front)
                .append(", [");

        for (int i  = 0; i < elements.length; i++) {
            if (i != 0) {
                string.append(", ");
            }
            string.append(elements[i]);
        }
        string.append("]");
        return string.toString();
    }
}