java 指定固定长度List实现先进先出

原创

mob649e816704bc 2024-09-13 05:58:31 ©著作权

©著作权归作者所有：来自51CTO博客作者mob649e816704bc的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 固定长度 List 实现先进先出（FIFO）队列

在 Java 编程中，队列（Queue）是一种非常重要的数据结构，它遵循先进先出（FIFO: First-In-First-Out）的原则。本文将探讨如何使用 Java 中的固定长度 List 来实现一个先进先出的队列，并提供代码示例、甘特图和表格，以帮助你更好地理解这一概念。

1. 概述

FIFO 队列是一种数据结构，其中最早插入的元素也最早被移除。常见的实际应用包括任务调度、打印队列等。Java 提供了多种实现队列的方式，本文将重点关注使用 ArrayList 和 LinkedList 来实现一个固定长度的 FIFO 队列。

2. 固定长度队列的实现

2.1 使用 ArrayList 实现 FIFO 队列

使用 ArrayList 可以相对简单地实现 FIFO 队列。我们需要保持一个固定长度的列表，同时管理元素的添加与删除。以下是实现的示例代码：

import java.util.ArrayList;

public class FixedSizeQueue<T> {
    private final int capacity;
    private final ArrayList<T> queue;
    private int head;
    private int size;

    public FixedSizeQueue(int capacity) {
        this.capacity = capacity;
        this.queue = new ArrayList<>(capacity);
        this.head = 0;
        this.size = 0;
    }

    public void enqueue(T element) {
        if (size < capacity) {
            queue.add(element);
            size++;
        } else {
            queue.set(head, element);
            head = (head + 1) % capacity;
        }
    }

    public T dequeue() {
        if (size == 0) {
            throw new IllegalStateException("Queue is empty");
        }
        T element = queue.get(head);
        head = (head + 1) % capacity;
        size--;
        return element;
    }

    public int getSize() {
        return size;
    }
}

2.2 使用 LinkedList 实现 FIFO 队列

虽然 ArrayList 是一种简单而高效的选择，LinkedList 也可以实现 FIFO 队列，尤其是在频繁添加和删除元素的情况下。以下是使用 LinkedList 的实现：

import java.util.LinkedList;

public class FixedSizeQueueLinkedList<T> {
    private final int capacity;
    private final LinkedList<T> queue;

    public FixedSizeQueueLinkedList(int capacity) {
        this.capacity = capacity;
        this.queue = new LinkedList<>();
    }

    public void enqueue(T element) {
        if (queue.size() == capacity) {
            queue.removeFirst(); // 移除头部元素
        }
        queue.addLast(element); // 添加新元素到尾部
    }

    public T dequeue() {
        if (queue.isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        return queue.removeFirst(); // 移除并返回头部元素
    }

    public int getSize() {
        return queue.size();
    }
}

3. 示例

我们可以通过以下示例代码来验证所实现的队列：

public class Main {
    public static void main(String[] args) {
        FixedSizeQueue<Integer> queue1 = new FixedSizeQueue<>(3);
        queue1.enqueue(1);
        queue1.enqueue(2);
        queue1.enqueue(3);
        System.out.println(queue1.dequeue()); // 输出: 1
        queue1.enqueue(4); // 1 将被替换
        System.out.println(queue1.dequeue()); // 输出: 2

        FixedSizeQueueLinkedList<Integer> queue2 = new FixedSizeQueueLinkedList<>(3);
        queue2.enqueue(1);
        queue2.enqueue(2);
        queue2.enqueue(3);
        System.out.println(queue2.dequeue()); // 输出: 1
        queue2.enqueue(4); // 1 将被替换
        System.out.println(queue2.dequeue()); // 输出: 2
    }
}

4. 甘特图

下图展示了 FIFO 队列的基本操作过程，我们可以把入队（Enqueue）和出队（Dequeue）操作视为任务，并用甘特图表示它们的执行顺序。

gantt
    title FIFO Queue Operations
    dateFormat  YYYY-MM-DD
    section Queue Operations
    Enqueue Element 1    :a1, 2023-10-01, 1d
    Enqueue Element 2    :a2, 2023-10-02, 1d
    Enqueue Element 3    :a3, 2023-10-03, 1d
    Dequeue Element 1    :a4, 2023-10-04, 1d
    Enqueue Element 4    :a5, 2023-10-05, 1d
    Dequeue Element 2    :a6, 2023-10-06, 1d