Java 队列（Queue）知识点详解

在 Java 编程中，队列（Queue）是一种重要的数据结构，遵循 ** 先进先出（FIFO, First-In-First-Out）** 原则，常用于任务调度、消息传递、资源管理等场景。本文将详细介绍 Java 队列的核心概念、常用实现类及典型应用场景。

一、队列的基本概念

1. 定义与特点

• 队列是一种线性数据结构，元素按 ** 入队（enqueue）** 顺序排列，先进入的元素优先出队（dequeue）。
• 类比现实中的排队场景（如银行柜台前的队列）。

2. 核心操作

• 入队（Offer/Put）：将元素添加到队尾。
• 出队（Poll/Remove）：移除并返回队首元素。
• 查看队首（Peek/Element）：返回队首元素但不移除。

3. 常见队列类型

• 普通队列（FIFO）：严格按入队顺序出队。
• 优先队列（PriorityQueue）：按元素优先级出队（基于比较器或自然顺序）。
• 双端队列（Deque）：支持队首和队尾双向操作。
• 阻塞队列（BlockingQueue）：线程安全，支持阻塞操作（如take()、put()）。

二、Java 中的 Queue 接口

1. 接口定义

public interface Queue extends Collection {
    boolean add(E e);      // 入队，失败时抛出异常
    boolean offer(E e);    // 入队，失败时返回false
    E remove();            // 出队，队列为空时抛出异常
    E poll();              // 出队，队列为空时返回null
    E element();           // 获取队首，队列为空时抛出异常
    E peek();              // 获取队首，队列为空时返回null
}

2. 方法对比

操作类型	抛出异常（失败时）	返回特殊值（失败时）
入队	add(e)	offer(e)
出队	remove()	poll()
查看队首	element()	peek()

三、常用队列实现类

1. LinkedList

• 特点：基于双向链表实现，支持队列和双端队列操作。
• 适用场景：频繁插入 / 删除元素的场景。

示例代码：

import java.util.LinkedList;
import java.util.Queue;

public class LinkedListQueueExample {
    public static void main(String[] args) {
        Queue queue = new LinkedList<>();
        queue.offer("A");
        queue.offer("B");
        queue.offer("C");
        
        System.out.println(queue.poll()); // 输出：A
        System.out.println(queue.peek()); // 输出：B
    }
}

2. PriorityQueue

• 特点：基于堆结构实现，元素按优先级排序。
• 适用场景：任务调度、Dijkstra 算法等需要优先级的场景。

示例代码：

import java.util.PriorityQueue;
import java.util.Queue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        Queue priorityQueue = new PriorityQueue<>(); // 默认升序
        priorityQueue.offer(3);
        priorityQueue.offer(1);
        priorityQueue.offer(2);
        
        System.out.println(priorityQueue.poll()); // 输出：1（最小元素优先）
    }
}

3. ArrayDeque

• 特点：基于数组实现的双端队列，不允许null元素。
• 适用场景：需要高效双端操作的场景（如栈或队列）。

示例代码：

import java.util.ArrayDeque;
import java.util.Deque;

public class ArrayDequeExample {
    public static void main(String[] args) {
        Deque deque = new ArrayDeque<>();
        deque.offerFirst("A"); // 队首插入
        deque.offerLast("B");  // 队尾插入
        
        System.out.println(deque.pollFirst()); // 输出：A
        System.out.println(deque.pollLast());  // 输出：B
    }
}

4. 阻塞队列（BlockingQueue）

• 特点：线程安全，支持阻塞操作（如take()、put()）。
• 常见实现类：
  • ArrayBlockingQueue：有界数组实现。
  • LinkedBlockingQueue：可选有界链表实现。
  • SynchronousQueue：仅容纳一个元素，每个插入必须等待另一个线程的移除。

生产者 - 消费者示例：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueExample {
    private static final BlockingQueue queue = new ArrayBlockingQueue<>(10);

    public static void main(String[] args) {
        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    queue.put(i);
                    System.out.println("生产者放入：" + i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    Integer item = queue.take();
                    System.out.println("消费者取出：" + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();
    }
}

四、队列的典型应用场景

1. 任务调度

• 场景：按提交顺序处理任务（如线程池中的任务队列）。
• 实现：使用LinkedBlockingQueue存储待执行任务。

2. 消息队列

• 场景：解耦生产者和消费者（如 Kafka、RabbitMQ 的底层实现）。
• 实现：使用BlockingQueue实现本地消息队列。

3. 广度优先搜索（BFS）

• 算法：遍历图或树时，使用队列存储待访问节点。
• 示例：

import java.util.LinkedList;
import java.util.Queue;

public class BFSTraversal {
    public void bfs(Node root) {
        Queue queue = new LinkedList<>();
        queue.offer(root);
        
        while (!queue.isEmpty()) {
            Node current = queue.poll();
            System.out.print(current.value + " ");
            
            if (current.left != null) queue.offer(current.left);
            if (current.right != null) queue.offer(current.right);
        }
    }
}

4. 缓存淘汰策略（如 FIFO）

• 策略：当缓存满时，优先淘汰最早进入的元素。
• 实现：自定义队列类，超出容量时自动移除队首元素。

五、常见问题与注意事项

1. 线程安全

• 非阻塞队列（如LinkedList、PriorityQueue）非线程安全，多线程环境下需使用Collections.synchronizedQueue()包装或手动同步。
• 阻塞队列（如ArrayBlockingQueue）线程安全，内部通过锁机制保证原子性。

2. 性能考虑

• LinkedList：插入 / 删除效率高（O (1)），随机访问效率低（O (n)）。
• ArrayDeque：双端操作效率高（O (1)），无容量限制时性能优于LinkedList。

3. 避免内存泄漏

• 使用有界队列（如ArrayBlockingQueue）防止队列无限增长导致 OOM。
• 及时处理队列中的元素，避免长时间积压。

六、总结

队列类型	实现类	线程安全	特点与适用场景
普通队列	LinkedList	否	基于链表，支持高效插入 / 删除
优先队列	PriorityQueue	否	元素按优先级排序，适用于任务调度
双端队列	ArrayDeque	否	基于数组，双端操作高效
阻塞队列	ArrayBlockingQueue	是	有界队列，支持阻塞操作
	LinkedBlockingQueue	是	可选有界队列，常用于生产者 - 消费者模型

通过掌握 Java 队列的核心接口和实现类，开发者可以根据场景选择合适的队列类型，高效解决任务调度、消息传递、算法实现等问题。