队列 链式存储Java实现

package com.wrh.lab.dataStructure.stackAndQueue;

/**
 * the interface of queue
 * @author wrh
 *
 * @param <E>
 */
public interface Queue<E> {
    
    /**
     * enqueue the element
     * @param element
     */
    public void enqueue(E element);
    
    /**
     * 
     * @return the dequeue element
     */
    public E dequeue(); 
    
    /**
     * get the first element of the queue
     * @return the first element of the queue
     */
    public E getFirstVal();
    
    /**
     * 
     * @return true for empty and false for not empty
     */
    public boolean isEmpty();
    
    /**
     * clear the queue
     */
    public void clear();
}

package com.wrh.lab.dataStructure.stackAndQueue;

public class QueueNode<E> {
    
    private E element;
    private QueueNode<E> next;
    
    /**
     * 
     */
    public QueueNode() {
        element = null;
        next = null;
    }
    
    public QueueNode(E element, QueueNode<E> next) {
        this.element = element;
        this.next = next;
    }

    public E getElement() {
        return element;
    }

    /**
     * @param element
     */
    public void setElement(E element) {
        this.element = element;
    }
    
    public QueueNode<E> getNext() {
        return next;
    }

    public void setNext(QueueNode<E> next) {
        this.next = next;
    }
}

package com.wrh.lab.dataStructure.stackAndQueueImpl;

/**
 * @author wrh
 * The implement of circular linked queue
 */
import com.trs.lab.dataStructure.stackAndQueue.Queue;
import com.trs.lab.dataStructure.stackAndQueue.QueueNode;

public class CircularLinkedQueueImpl<E> implements Queue<E> {
    private QueueNode<E> front;
    private QueueNode<E> rear;
    
    /**
     * constructor
     */
    public CircularLinkedQueueImpl() {
        front = rear = null;
    }
    
    @Override
    public void enqueue(E element) {
        if (null != rear) {    // if the queue is not empty
            rear.setNext(new QueueNode(element,null));
            rear = rear.getNext();
        } else {
            front = rear = new QueueNode(element, null);
        }
    }

    @Override
    public E dequeue() {
        if (isEmpty()) {
            System.out.println("the queue is empty!");
            return null;
        } else {
            E e = front.getElement();
            front = front.getNext();
            return e;
        }
    }

    @Override
    public E getFirstVal() {
        if (isEmpty()) {
            System.out.println("the queue is empty");
            return null;
        } else {
            return front.getElement();
        }
    }

    @Override
    public boolean isEmpty() {
        return null == front;
    }

    @Override
    public void clear() {
        front = rear = null;
    }
    
    public static void main(String[] args) {
        Queue<Integer> q = new CircularLinkedQueueImpl<Integer>();
        q.dequeue();
        q.enqueue(1);
        q.enqueue(2);
        q.enqueue(3);
        q.enqueue(4);
        System.out.println(q.getFirstVal());
        System.out.println(q.dequeue());
        System.out.println(q.dequeue());
        System.out.println(q.dequeue());
        System.out.println(q.dequeue());
        
    
    }

}