生活中，排队随处可见。下面我们就使用java来实现简单的队列吧。

首先，给出接口的定义，也就是规定队列的行为...

package net.itaem.list;

/**
 * 定义一个队列的接口
 * 
 * 队列的定义：FIRST IN FIRST OUT
 * 
 * @author luohong QQ 846705189
 * */
public interface Queue<T> {
    
	/**
	 * 在队尾加入一个元素
	 * */
	public void in(T e);
	
	/**
	 * 从队列头部弹出一个元素，并且删除头部元素
	 * */
	public T out();
	
	/**
	 * 返回队列元素长度
	 * */
	public int size();
	
	/**
	 * 清空一个队列
	 * */
	public void clear();
	
	/**
	 * 获得队列的第一个元素，不删除
	 * */
	public T getFirst();
	
	/**
	 * 获得队列的最后一个元素，不删除
	 * */
	public T getLast(); 
}

package net.itaem.list.impl;

import net.itaem.list.Queue;

/**
 * 使用数组来实现一个队列
 * 
 * 这个队列在初始化时就已经确定了队列可以容纳的数量，并且不会动态增长...
 * 
 * @author luohong QQ 846705189
 * 
 * */
public class ArrayQueue<T> implements Queue<T>{

	//队列首部
	private int first;

	//队列尾部的下一个元素
	private int last;
	//定义一个Object[]来保存队列的元素
	private Object[] elements;
	//队列元素的size
	private int size;
	//队列最多能保存的元素个数
	private int length;

	public ArrayQueue(){
		//默认情况下，长度为10
		this(10);
	}
	
	public ArrayQueue(int length){
		if(length < 0) throw new RuntimeException("sorry，不能为负数");
		this.length = length +1;	
		elements = new Object[this.length];
	}


	@Override
	public void in(T e) {
		if(last < length-1){
			size++;
			elements[last++] = e;
		}else{
			throw new RuntimeException("队列已满，不可以继续添加元素");
		}
	}

	@SuppressWarnings("unchecked")
	@Override
	public T out() {
		T result = null;

		if(size > 0) {
			result = (T)elements[first];   //这里的first一直都等于0

			for(int i=0; i<size; i++){
				elements[i] = elements[i+1];   //移动后面的算有元素
			}
			//尾部元素移动
            last--;
			//元素长度减去一
			size--;
		}else{
			throw new RuntimeException("队列为空，不能继续弹出元素");
		}

		return result;
	}

	@Override
	public int size() {
		return size;
	}

	@Override
	public void clear() {
		//清空数组的所有应用，防止造成内容溢出
		for(int i=0; i<size; i++){
			elements[i] = null;
		}
		last = 0;
		size = 0;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T getFirst() {
		if(size > 0)
			return (T)elements[0];
		else
			return null;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T getLast() {
		if(size > 0)
			return (T)elements[last-1];
		else 
			return null;
	}

	public String toString(){
		StringBuilder sb = new StringBuilder();
		
		if(size == 0) sb.append("null");
		
		else
			for(int i=0; i<size; i++){
				sb.append(elements[i] + " ");
			}
		return "the queue size is " + size + " and the element is " + sb.toString();
	}

	public static void main(String[] args) {
		Queue<Integer> intQueue = new ArrayQueue<Integer>(10);

		
		for(int i=0; i<10; i++){
			intQueue.in(i);
		}

		System.out.println("before out " + intQueue);
		
		System.out.print("queue out ");
		for(int i=0; i<10; i++){
			System.out.print(intQueue.out() + " ");
		}
		
		System.out.println("");
		
		System.out.println("after out " + intQueue);
		
		//1000进入队列
		intQueue.in(1000);
		System.out.println(intQueue.getFirst());
		System.out.println(intQueue.getLast());
		System.out.println("after 1000 in queue and " + intQueue);
		
	}

}

before out the queue size is 10 and the element is 0 1 2 3 4 5 6 7 8 9 
queue out 0 1 2 3 4 5 6 7 8 9 
after out the queue size is 0 and the element is null
1000
1000
after 1000 in queue and the queue size is 1 and the element is 1000 

上面使用数组实现的顺序队列，在使用上有着很大的闲置。因为会造成假溢出现象，并且长度是有限制的，不能动态的增长，而且在弹出元素时，算法效率低下...所以这种情况，可以使用循环队列。不过链式队列可以更加灵活的改善这些缺点，下面给出链式队列

package net.itaem.list.impl;

import net.itaem.list.Queue;

public class LinkedQueue<T> implements Queue<T> {

	private class Node<E>{
		private E data;
		private Node<E> next;

		public Node(E data, Node<E> next){
			this.data = http://www.mamicode.com/data;>
输出结果
before out
 queue size is 10 and the element is 0 1 2 3 4 5 6 7 8 9 
out queue 0123456789
after out queue size is 0 and the element is null
first and last is 1000 1000
1000 in queue size is 1 and the element is 1000 
after clear queue size is 0 and the element is null 


队列