同我之前写的博客–有关栈的实现一样，队列的实现也有两种方式。

方式一：基于链表实现

代码：

public class LinkQueue<E> {
    private Node<E> head = null;
    private Node<E> tail = null;

    public boolean isEmpty() {
        return head == tail;
    }

    public void add(E data) {
        Node<E> newNode = new Node<>(data);
        //
        if (head == null && tail == null) {
            head = tail = newNode;
        } else {
            tail.next = newNode;
            tail = newNode;
        }
    }

    public E poll() {
        if (this.isEmpty()) {
            return null;
        }
        E data = head.data;
        head = head.next;
        return data;
    }

    public int size() {
        Node<E> tmp = head;
        int n = 0;
        while (tmp != null) {
            tmp = tmp.next;
        }
        return n;
    }
}

class Node<E> {
    Node<E> next = null;
    E data;

    public Node(E data) {
        this.data = data;
    }
}

数组实现队列

在JDK的java.util包中不论是Stack还是Queue都是在相应的方法中声明了sychroniz以保证线程同步

public class ArrayQueue<E> {
    Object[] queue;
    int size;
    public ArrayQueue(){
        queue = new Object[10];
    }

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

    public void ensureCapacity(){
        int len = queue.length;
        if (size+1 > len) {
            int newLen = len = 10;
            queue = Arrays.copyOf(queue, newLen);
        }
    }

    public void add(E data){
        ensureCapacity();
        size++;
        queue[size] = data;
    }

    public Object poll(){
        if (isEmpty()){
            return null;
        }
        size--;
        return queue[size];
    }
    
    public Object peek(){
        if (isEmpty()){
            return null;
        }
        return queue[size-1];
    }
}