队列的Java实现

一.概述
队列是一种基于先进先出(FIFO)的数据结构，是一种只能在一端进行插入,
在另一端进行删除的特殊线性表， 它按照先进先出的原则存储数据，先进入的数据，在读取数据时先读被读出来。

插入元素时：每次直接插到末尾即可（尾插法），新插入的元素即为新的尾结点last。（区别于栈的头插法）

取出元素时：返回首结点指向的下一个元素即可。（先进先出），此时和弹栈一样。

总结：队列为尾插头取，栈为头插头取

二.用链表实现队列

public class Queue<T> implements Iterable<T>{
    private Node head;
    private Node last;
    private int N;

    private class Node{  //内部类
        public T item; //链表所存元素
        public Node next;

        public Node(T item,Node next){//Node的有参构造
            this.item=item;
            this.next=next;
        }
    }


    public Queue(){ //队列的构造
        this.head=new Node(null,null); //head结点不存储元素
        this.last=null;
        this.N=0;
    }


    public boolean isEmpty(){
        return N==0;
    }


    public int size(){
        return N;
    }

    //尾插
    public void enqueue(T t){
    if(last==null){ //尾结点为null
        last=new Node(t,null);
        head.next=last;
    }else{ //尾结点不为null
        Node oldlast=last;//记录旧尾结点
        last=new Node(t,null); //更新尾结点
        oldlast.next=last;//旧的尾结点指向新的尾结点
    }
        N++;
    }

    //头取
    public T dequeue(){
    if(isEmpty()){
        return null;
    }else{
        Node oldFirst=head.next;//旧的首结点的下一个结点
        head.next=oldFirst.next;//更新首结点的下一个结点
        N--;
        //因为取元素是在删除，如果删完了就需要重置last=null;
        if(isEmpty()){
            last=null;
        }
        return oldFirst.item;//先进先出， 头取
        }
    }



    @Override
    public Iterator<T> iterator() {
        return new MyIterator();}

    private class MyIterator implements Iterator{
        private Node n;//记录每次遍历的结点

        MyIterator(){
            this.n=head;
        }

        @Override
        public boolean hasNext() {
            return n.next!=null;
        }

        @Override
        public Object next() {
            n=n.next;
            return n.item;
        	}
        }

    public static void main(String[] args) {
        Queue<String> q=new Queue();
        q.enqueue("a");
        q.enqueue("b");
        q.enqueue("c");
        q.enqueue("d");

        for(String k:q){
            System.out.println(k);
        }
        System.out.println("==========");
        System.out.println(q.dequeue()); //删除一个元素（先进先出）
        System.out.println("==========");
        for(String k:q){
            System.out.println(k);
        }
    }
}

测试结果：

a
b
c
d
==========
a
==========
b
c
d