java实现的循环队列

ArrayQueueLoop

package 队列;
/*
 * 循环队列。
 * front指向队头元素，rear指向队尾元素的下一个位置
 * 队列为空条件:front==rear; 头指针==尾指针
 * 队列满条件:(rear+1)%capaticy==front;
 * capaticy代表队列的最大容量
 * 队列长度计算公式：
 * 当front<rear时：size=rear-front;
 * 当front>rear时；第一段size=capaticy-front;
 *               第二段size=0+rear;
 * 所以通用的长度计算公式为：
 * size=(rear-front+capacity)%capacity;
 */
public class ArrayQueueLoop<E> implements Queue<E> {
	E[] data;
	int front;
	int rear;
	//int size=(rear-front+data.length)%data.length;
	int size;
	public ArrayQueueLoop() {
		this(10);
	}

	public ArrayQueueLoop(int capacity) {
		data =(E[]) new Object[capacity];
		size=0;
		front=0;
		rear=0;
	}

	@Override
	public String toString() {
		if(isEmpty()) {
			return "[]";
		}
		/*
		 * 从front开始打印，结束点为rear
		 */
		StringBuilder  sb=new StringBuilder("[");
		for(int i=front;i!=rear;i=(i+1)%data.length){
			if((i+1)%data.length==rear){
				sb.append(data[i]+"]");
			}else{
				sb.append(data[i]+",");
			}
		}
		return sb.toString();
	}
	@Override
	public int getSize() {
		// TODO Auto-generated method stub
		return this.size;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return getSize()==0;
	}

	@Override
	public void enqueue(E e) {
		// TODO Auto-generated method stub
		/*
		 * 首先判断队列是否满了
		 */
		if((rear+1)%data.length==front) {
			throw new IllegalArgumentException("队列已满");
		}
		data[rear]=e;
		rear=(rear+1)%data.length;
		size++;
	}

	@Override
	public E dequeue() {
		// TODO Auto-generated method stub
		/*
		 * 判断队列是否为空
		 */
		if(front==rear) {
			throw new IllegalArgumentException("队列为空");
		}
		E flag=data[front];
		front=(front+1)%data.length;
		size--;
		return flag;
	}

	@Override
	public E getFront() {
		// TODO Auto-generated method stub
		if(isEmpty()) {
			throw new IllegalArgumentException("队列为空");
		}
		return data[front];
	}

	@Override
	public E getRear() {
		// TODO Auto-generated method stub
		if(isEmpty()) {
			throw new IllegalArgumentException("队列为空");
		}
		/*
		 * 这里分析当尾指针的两种情况，当尾指针位置为0时和不为0时
		 */
		if(rear==0) {
			return data[data.length-1];
		}
		return data[rear-1];
		//这里为什么rear-1？？
		//因为rear指向的队尾元素的下一个位置，
		//也就是下一个准备要插的元素的位置
	}

	@Override
	public void clear() {
		// TODO Auto-generated method stub
		front=0;
		rear=0;
		size=0;
	}
}

测试

package 队列;

public class TestArrayQueueLoop {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayQueueLoop<Integer> loop=new ArrayQueueLoop<>(20);
		System.out.println(loop);
		loop.enqueue(888);
		loop.dequeue();
		loop.enqueue(888);
		loop.enqueue(85);
		loop.enqueue(18);
		loop.enqueue(545);
		System.out.println(loop.getFront());
		System.out.println(loop);
	}
}

测试结果

[]
888
[888,85,18,545]