Java实现FIFO功能的完整代码实践

/**
 * FifoQueueDemo.java
 *
 * 本示例演示如何用 Java 自定义实现 FIFO（先进先出）队列功能。
 *
 * 功能包括：
 *  - 定义节点类（Node）表示链表节点，存储数据及指向下一个节点的引用；
 *  - 实现 FIFO 队列类（FifoQueue），提供入队（enqueue）、出队（dequeue）、窥视（peek）、
 *    判断空队列（isEmpty）和获取队列大小（size）等操作；
 *  - 在主方法中演示队列操作，并输出操作结果验证功能正确性。
 *
 * 注：本示例采用单链表实现队列，并利用 Java 泛型实现通用性。
 */
public class FifoQueueDemo {
 
    /**
     * FifoQueue 泛型类，实现 FIFO 队列功能。
     *
     * @param <T> 队列中存储的数据类型
     */
    public static class FifoQueue<T> {
        /**
         * 内部静态类 Node 表示链表节点，包含数据域和指向下一个节点的引用。
         */
        private static class Node<T> {
            T data;       // 当前节点存储的数据
            Node<T> next; // 指向下一个节点的引用
 
            public Node(T data) {
                this.data = data;
                this.next = null;
            }
        }
 
        private Node<T> head; // 队头指针，指向第一个元素
        private Node<T> tail; // 队尾指针，指向最后一个元素
        private int size;     // 队列中元素的个数
 
        /**
         * 构造方法，初始化空队列。
         */
        public FifoQueue() {
            head = null;
            tail = null;
            size = 0;
        }
 
        /**
         * 入队操作：在队尾添加一个元素。
         *
         * @param item 要添加的元素
         */
        public void enqueue(T item) {
            Node<T> newNode = new Node<>(item);
            // 如果队列为空，则新节点同时作为头和尾
            if (isEmpty()) {
                head = tail = newNode;
            } else {
                // 否则，将新节点链接到尾部，并更新 tail 指针
                tail.next = newNode;
                tail = newNode;
            }
            size++;
        }
 
        /**
         * 出队操作：从队头取出并移除一个元素。
         *
         * @return 队头元素，如果队列为空则抛出运行时异常
         */
        public T dequeue() {
            if (isEmpty()) {
                throw new RuntimeException("队列为空，无法执行出队操作！");
            }
            T data = head.data;
            head = head.next;
            // 如果移除后队列为空，则 tail 也需要设置为 null
            if (head == null) {
                tail = null;
            }
            size--;
            return data;
        }
 
        /**
         * 窥视操作：查看队头元素但不移除。
         *
         * @return 队头元素，如果队列为空则抛出运行时异常
         */
        public T peek() {
            if (isEmpty()) {
                throw new RuntimeException("队列为空，无法窥视！");
            }
            return head.data;
        }
 
        /**
         * 判断队列是否为空。
         *
         * @return 如果队列为空则返回 true，否则返回 false
         */
        public boolean isEmpty() {
            return size == 0;
        }
 
        /**
         * 获取队列中元素的个数。
         *
         * @return 队列大小
         */
        public int size() {
            return size;
        }
 
        /**
         * 重写 toString() 方法，返回队列中所有元素的字符串表示。
         *
         * @return 队列字符串表示
         */
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append("[");
            Node<T> current = head;
            while (current != null) {
                sb.append(current.data);
                if (current.next != null) {
                    sb.append(", ");
                }
                current = current.next;
            }
            sb.append("]");
            return sb.toString();
        }
    }
 
    /**
     * 主方法，演示 FIFO 队列的各项基本操作。
     *
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        // 创建一个存储 Integer 类型的 FIFO 队列实例
        FifoQueue<Integer> queue = new FifoQueue<>();
        System.out.println("初始队列: " + queue);
 
        // 入队操作：依次向队列中添加元素
        queue.enqueue(10);
        queue.enqueue(20);
        queue.enqueue(30);
        System.out.println("入队后: " + queue);
 
        // 窥视操作：查看队头元素
        System.out.println("队头元素: " + queue.peek());
 
        // 出队操作：移除并返回队头元素
        int removed = queue.dequeue();
        System.out.println("出队元素: " + removed);
        System.out.println("出队后: " + queue);
 
        // 输出当前队列大小
        System.out.println("当前队列大小: " + queue.size());
    }
}