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

原理
向队列中插入数据
1.将尾节点的指针域指向新节点
2.将新节点作为新的尾节点

从队列中获取数据
1.获取第一个节点、第二个节点
2.将头节点的指针域指向第二个节点
3.将第一个节点的数据域的数据返回

示例

package wxw.mengyuan.demo;
import java.util.Iterator;

/**
 * 堆代码 duidaima.com
 * 队列
 */
public class Queue<T> implements Iterable<T> {

  /** 头节点 */
  private Node<T> head;
  /** 尾节点 */
  private Node<T> foot;
  /** 存储的数据个数 */
  private int N;

  /**
   * 内部节点类
   */
  private static class Node<T> {
    // 当前节点存储的数据
    private T data;
    // 指向下一个节点的指针
    private Node<T> next;

    /**
     * 构造方法
     */
    public Node(T data, Node<T> next) {
      this.data = data;
      this.next = next;
    }
  }

  /**
   * 构造方法
   */
  public Queue() {
    // 初始化头节点
    head = new Node<>(null, null);
    // 初始化尾节点
    foot = null;

    // 初始化存储的数据个数
    N = 0;
  }

  /**
   * 向队列中插入数据
   *
   * 原理
   * (1) 将尾节点的指针域指向新节点
   * (2) 将新节点作为新的尾节点
   *
   * @param data 新节点的数据
   */
  public void enqueue(T data) {
    // 创建新节点
    Node<T> newNode = new Node<>(data, null);

    if (isEmpty()) {
      // 队列中没有数据时，那么将新节点作为尾节点
      foot = newNode;
      // 让头节点指向新的尾节点
      head.next = foot;
    } else {
      // 队列中有数据时，那么将新节点作为节点的下一个节点
      foot.next = newNode;
      // 设置新节点为新的节点
      foot = newNode;
    }

    // 存储的数据个数+1
    N++;
  }

  /**
   * 从队列中获取数据
   *
   * 原理
   * (1) 获取第一个节点、第二个节点
   * (2) 将头节点的指针域指向第二个节点
   *
   * @return 第一个结点中的数据
   */
  public T dequeue() {
    // 如果队列中没有数据，直接返回null
    if (isEmpty()) {
      return null;
    }
    // 获取第一个节点
    Node<T> firstNode = head.next;
    // 让头节点指向第二节点
    head.next = firstNode.next;
    // 将第一个节点的指针域置为null：便于释放资源
    firstNode.next = null;
    // 存储的数据个数-1
    N--;

    // 返回第一个结点的数据
    return firstNode.data;
  }

  /**
   * 遍历队列
   */
  @Override
  public Iterator<T> iterator() {
    return new QueueIterator();
  }

  /**
   * 内部类：用于遍历
   */
  private class QueueIterator implements Iterator<T> {
    // 当前节点，默认指向头节点
    private Node<T> node = head;

    /**
     * 判断是否还有下一个节点
     */
    @Override
    public boolean hasNext() {
      return node.next != null;
    }

    /**
     * 获取下一个节点中的数据
     */
    @Override
    public T next() {
      // 获取下一个节点
      node = node.next;
      // 返回下一个节点中的数据
      return node.data;
    }
  }

  /**
   * 判断队列是否为空
   *
   * @return true：空队列
   */
  public boolean isEmpty() {
    return N == 0;
  }

  /**
   * 获取队列中存储的数据个数
   *
   * @return 队列中存储的数据个数
   */
  public int size() {
    return N;
  }

}