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());
    }
}