直接上代碼吧

package com.sbtufss.test;
/**
 * 隊列是從隊尾插入，隊頭出去，當為空隊列時，隊尾的next指向對頭，隊頭和隊尾的data都不存儲數據
 */
public class LinkQueue<T> {
    Node<T> front;//隊頭
    Node<T> rear;//隊尾
    public LinkQueue(){
        super();
        initQueue();
    }
    //當為空隊列是，頭節點和尾節點指向同一個節點
    private void initQueue(){
        front
 
=new Node<T>();
        rear=new Node<T>();
        rear.setNext(front);
        front.setPre(rear);
    }
    
    /**
     * 插入數據，數據是從隊尾插入
     */
    public void add(T data){
        Node<T> node=new Node<T>();
        node.setData(data);
        node.setNext(rear.next);//將該節點的next指向隊尾的next
 

        node.setPre(rear);
        rear.getNext().setPre(node);
        rear.setNext(node);//然後再將隊尾的next指向該節點，從而建立了關系，插入了鏈表
    }
    
    /**
     * 獲取數據，獲取數據是從對頭出隊列的
     */
    public T poll(){
        if(rear.getNext()==front){
            return null;
        }
        Node<T> node=front.getPre();
        node.pre.setNext(front);
 
//將對頭的上一個指針的上一個指針的next設置為隊頭，然後該指針出隊列
        front.setPre(node.pre);
        return node.getData();
    }
    
    /**
     * 清空隊列
     */
    public void clear(){
        while(rear.getNext()!=front){
            Node<T> node=rear.getNext();
            rear.setNext(node.getNext());
            node.getNext().setPre(rear);
            node=null;//清空數據，等待虛擬機回收
        }
    }
    
    /**
     * 打印隊列裏面的數據,從對頭開始打
     */
    @Override
    public String toString() {
        Node<T> node=front.getPre();
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        while(node!=rear){
            sb.append(node.getData()).append(",");
            node=node.getPre();
        }
        if(sb.length()!=1){
            sb.deleteCharAt(sb.length()-1);
        }
        sb.append("]");
        return sb.toString();
    }
    
    private class Node<M>{
        private M data;
        private Node<M> next;
        private Node<M> pre;
        public Node() {
            super();
        }
        public M getData() {
            return data;
        }
        public void setData(M data) {
            this.data = data;
        }
        public Node<M> getNext() {
            return next;
        }
        public void setNext(Node<M> next) {
            this.next = next;
        }
        public Node<M> getPre() {
            return pre;
        }
        public void setPre(Node<M> pre) {
            this.pre = pre;
        }
    }
}

測試

package com.sbtufss.test;


public class Test {
    
    public static void main(String[] args) {
        LinkQueue<String> queue=new LinkQueue<>();
        queue.add("a");
        queue.add("b");
        queue.add("c");
        queue.add("d");
        System.out.println("queue.toString():"+queue);
        String s=queue.poll();
        System.out.println("取出對頭的值:"+s);
        System.out.println("queue.toString():"+queue);
        queue.clear();
        System.out.println("queue.toString():"+queue);
        queue.add("e");
        queue.add("f");
        System.out.println("queue.toString():"+queue);
    }
    
}

測試結果

隊列的鏈式存儲結構