循环队列(贪吃蛇版)

特殊功能的循环队列

特点:

一.入队列不会满的情况下,会覆盖掉尾部的数据.

二.快速从尾部获取指定个数个数据.

代码:

public class LoopQueue<T> implements Serializable {

    private static final long serialVersionUID = -3670496550272478781L;

    private int DEFAULT_SIZE = 100;

    private int capacity;// 保存数组的长度

    private Object[] elementData;// 定义一个数组用于保存循环队列的元素

    private int front = 0;// 队头

    private int rear = 0;// 队尾

    // 以默认数组长度创建空循环队列
    public LoopQueue() {
        capacity = DEFAULT_SIZE;
        elementData = new Object[capacity];
    }

    // 以一个初始化元素来创建循环队列
    public LoopQueue(T element) {
        this();
        elementData[0] = element;
        rear++;
    }

    /**
     * 以指定长度的数组来创建循环队列
     * 
     * @param element
     *            指定循环队列中第一个元素
     * @param initSize
     *            指定循环队列底层数组的长度
     */
    public LoopQueue(T element, int initSize) {
        this.capacity = initSize;
        elementData = new Object[capacity];
        elementData[0] = element;
        rear++;
    }

    /**
     * 获取循环队列的大小
     * 
     * @return
     */
    public int size() {
        if (isEmpty()) {
            return 0;
        }
        return rear > front ? rear - front : capacity - (front - rear);
    }

    /**
     * 入队列
     * 
     * @param element
     */
    public void offer(T element) {
        if (size() == capacity) {
            // throw new IndexOutOfBoundsException("队列已满的异常");
            front = rear + 1;
            front = front == capacity ? 0 : front;
        }
        elementData[rear++] = element;
        // 如果rear已经到头，那就转头
        rear = rear == capacity ? 0 : rear;
    }

    /**
     * 出队列
     * 
     * @return
     */
    public T poll() {
        if (isEmpty()) {
            return null;
        }
        // 保留队列的rear端的元素的值
        @SuppressWarnings("unchecked")
        T oldValue = (T) elementData[front];
        // 释放队列的rear端的元素
        elementData[front++] = null;
        // 如果front已经到头，那就转头
        front = front == capacity ? 0 : front;
        return oldValue;
    }

    // 返回队列顶元素，但不删除队列顶元素
    @SuppressWarnings("unchecked")
    public T element() {
        if (isEmpty()) {
            return null;
        }
        return (T) elementData[front];
    }

    // 判断循环队列是否为空队列
    public boolean isEmpty() {
        // rear==front且rear处的元素为null
        return rear == front && elementData[rear] == null;
    }

    // 清空循环队列
    public void clear() {
        // 将底层数组所有元素赋为null
        Arrays.fill(elementData, null);
        front = 0;
        rear = 0;
    }

    /**
     * 从尾部获取指定个数个数据
     * 
     * @param count
     * @return
     */
    public List<T> getElementsFormRear(int count) {
        List<T> result = new ArrayList<>();
        int min = size() < count ? size() : count;
        int num = 0;
        for (int i = rear - 1; num < min; i--) {
            i = i < 0 ? capacity - 1 : i;
            @SuppressWarnings("unchecked")
            T t = (T) elementData[i];
            result.add(t);
            num++;
        }
        return result;
    }

    public static void main(String[] args) {
        LoopQueue<Integer> loopQueue = new LoopQueue<>();
        for (int i = 0; i < 80; i++) {
            loopQueue.offer(i);
            System.out.println(JsonUtil.ObjectToJsonString(loopQueue.getElementsFormRear(4)));
        }
    }
}