循环队列

循环队列：双指针
front：头指针
rear：尾指针，指向一个空的位置


Queue接口

//Queue接口继承Iterable接口
public interface Queue<E> extends Iterable<E> {
        //获取有效个数
        int getSize();
        //判断是否为空
        boolean isEmpty();
        //入队一个元素
        void enqueue(E e);
        //出队一个元素
        E dequeue();
        //获取队头
        E getFront();
        //获取队尾
        E getRear();
        //清空队
        void clear();
}

循环队列类

import java.util.Date;
import java.util.Iterator;
//循环队列类实现Queue接口  <E>--泛型
public class ArrayQueueLoop<E> implements Queue<E>{
    private E[] data;
    private int front;  //头指针
    private int rear;   //尾指针
    private int size;   //有效长度
    public ArrayQueueLoop(){    //无参构造函数
        //默认长度为11，其中有一个为rear指向的空位置，所以实际长度为10
        data=(E[])(new Object[11]);
        front=0;
        rear=0;
        size=0;
    }
    @Override
    public int getSize() {
        return size;
    }
    @Override
    public E getFront() {
        if(isEmpty()){
            throw new IllegalArgumentException("队列为空");
        }
        return data[front];
    }
    //获取尾指针指的前一位
    @Override
    public E getRear() {
        if(isEmpty()){
            throw new IllegalArgumentException("队列为空");
        }else {
            //循环，当rear指向第一个位置时，其实际要找到最后一个位置的数
            return data[(rear-1+data.length)%data.length];
        }
    }
    @Override
    public boolean isEmpty() {
        return front==rear&&size==0;
    }
    @Override
    public void enqueue(E e) {
        //栈满，若front指向第一个位置，rear指向最后一个位置，循环
        if(front==(rear+1)%data.length){
            resize(data.length*2-1);  //扩容，不要忘记有一个空位置
        }else{
            data[rear]=e;
            rear=(rear+1)%data.length;//循环
            size++;
        }
    }
    @Override
    public E dequeue() {
        if(isEmpty()){
            throw new IllegalArgumentException("队列为空");
        }else {
            E ret = data[front];
            //循环，若front指向最后一个位置
            front=(front+1)%data.length;
            size--;
            //如果有效长度小于等于总长度的1/4,并且长度的一半大于等于10——不要忘记有一个空位置
            if(size<=(data.length-1)/4&&(data.length-1)/2>=10){
                resize((data.length-1)/2+1);
            }
            return ret;
        }
    }
    private void resize(int newLen) {
        int i=0;
        E[] newData=(E[])(new Object[newLen]);
        for (int p = front; p!=rear; p=(p+1)%data.length) { //循环
            newData[i]=data[p];
            i++;
        }
        front=0;
        rear=size;
        data=newData;
    }
    @Override
    public void clear() {
        data=(E[])(new Object[11]);
        front=0;
        rear=0;
        size=0;
    }

    //5(有效长度)/11(总长度)
    //[1,2,3,4,5]
    @Override
    public String toString() {
        StringBuilder sb=new StringBuilder();
        sb.append(String.format("ArrayQueueLoop:%d/%d\n",size,data.length));
        sb.append('[');
        if(isEmpty()){
            sb.append(']');
        }
        else{
            for (int i = front; i <rear ; i=(i+1)%data.length) {
                sb.append(data[i]);
                if(i==(rear-1+data.length)%data.length){
                    sb.append(']');
                }else {
                    sb.append(',');
                }
            }
        }
        return sb.toString();
    }
    //iterator方法
    @Override
    public Iterator<E> iterator() {
        return new ArrayQueueLoopIterator();
    }
    private class ArrayQueueLoopIterator  implements Iterator{
        @Override
        public boolean hasNext() {   //判断是否有下一个
            return front!=rear;
        }
        @Override
        public Object next() {
            E ret=data[front];
            front=(front+1)%data.length;
            return ret;
        }
    }
}

测试类

public class TestArrayQueueLoop {
    public static void main(String[] args) {
        ArrayQueueLoop<Integer> loop=new ArrayQueueLoop<>();
        System.out.println(loop);
        for(int i=1;i<=8;i++){
            loop.enqueue(i);
        }
        System.out.println(loop);

        for(int i=1;i<=6;i++){
            loop.dequeue();
        }
        System.out.println(loop);
        for(Integer i:loop){
            System.out.print(i+" ");
        }
    }
}