Java中PriorityQueue的基础使用方法-java教程-PHP中文网

Java中PriorityQueue的基础使用方法

P粉602998670

发布： 2025-09-22 18:00:02

原创

780人浏览过

PriorityQueue是Java中基于优先级出队的队列，默认为小顶堆，每次取出最小元素；其核心方法包括add/offer入队、poll出队、peek查看队首；与普通FIFO队列不同，它按元素优先级排序而非入队顺序；可通过实现Comparable接口或传入Comparator自定义排序规则；常用于Dijkstra算法、任务调度、Top K问题等需动态处理最高优先级元素的场景。

java中priorityqueue的基础使用方法

Java里的

PriorityQueue

登录后复制

，说白了，就是一种特殊的队列。它不像我们常说的先进先出（FIFO）队列那样，而是根据元素的优先级来决定谁先出队。默认情况下，它是一个小顶堆，这意味着每次你取元素，拿到的总是当前队列里最小的那个。这在很多需要“总是处理最紧急或最小/最大”元素的场景下，简直是神来之笔。

我个人觉得，理解

PriorityQueue

登录后复制

的基础用法并不复杂，核心就是那么几个方法。

首先，创建它。如果你想用默认的自然排序（比如数字从小到大），直接

new PriorityQueue<Integer>()

登录后复制

就行。如果你处理的是自定义对象，或者想实现大顶堆（从大到小），那就得传入一个

Comparator

登录后复制

。比如：

// 默认小顶堆，存储整数
PriorityQueue<Integer> minHeap = new PriorityQueue<>();

// 大顶堆，存储整数
PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a); // 或者 Comparator.reverseOrder()

// 存储自定义对象，假设有一个Task类，根据priority字段排序
class Task {
    String name;
    int priority; // 优先级，数字越小优先级越高

    public Task(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }

    @Override
    public String toString() {
        return "Task{" + "name='" + name + '\'' + ", priority=" + priority + '}';
    }
}

PriorityQueue<Task> taskQueue = new PriorityQueue<>(Comparator.comparingInt(t -> t.priority));

登录后复制

接着是往里面加元素，用

add()

登录后复制

或者

offer()

登录后复制

都可以。它们俩在功能上几乎没区别，

offer()

登录后复制

在容量受限的队列中可能返回

false

登录后复制

，但

PriorityQueue

登录后复制

是无界的，所以一般都成功。

立即学习“Java免费学习笔记（深入）”；

minHeap.add(3);
minHeap.offer(1);
minHeap.add(2);
System.out.println("当前队列 (内部表示，不保证顺序): " + minHeap); // 内部顺序不保证，但poll()会取1

登录后复制

然后就是取元素。

peek()

登录后复制

是查看队首元素，但不移除；

poll()

登录后复制

是取出队首元素并移除。这两个方法是用的最多的。

System.out.println("队首元素 (不移除): " + minHeap.peek()); // 输出 1
System.out.println("移除队首元素: " + minHeap.poll());    // 输出 1
System.out.println("移除后的队首元素: " + minHeap.peek()); // 输出 2
System.out.println("队列大小: " + minHeap.size());        // 输出 2
System.out.println("队列是否为空: " + minHeap.isEmpty()); // 输出 false

登录后复制

有时候，我发现新手会忘记

poll()

登录后复制

会移除元素，导致后续操作出错，所以在使用时务必明确是想“看一眼”还是“拿走”。

PriorityQueue与普通队列的本质区别在哪里？

说实话，这个问题我被问过好多次，也自己琢磨过。最核心的区别，我觉得，就在于“出队顺序”的决定机制。普通队列，比如

LinkedList

登录后复制

实现的

Queue

登录后复制

，是严格的先进先出（FIFO），你第一个放进去的，就第一个出来。这就像排队买票，谁先来谁先买。

但

PriorityQueue

登录后复制

就不同了，它关注的是“优先级”。谁的优先级高，谁就先出来，跟进队顺序无关。这就像医院的急诊室，病人来了不按先来后到，而是根据病情轻重（优先级）来决定谁先看医生。这种内在的排序机制，使得

PriorityQueue

登录后复制

在处理那些需要动态调整处理顺序的场景时，显得异常强大。它的底层通常是用一个二叉堆（min-heap或max-heap）来实现的，这保证了

poll()

登录后复制

和

add()

登录后复制

操作的平均时间复杂度是O(log n)，效率相当不错。所以，如果你需要一个总是能拿到“最紧急”或“最小/最大”元素的集合，

PriorityQueue

登录后复制

就是你的不二之选。

如何灵活地自定义PriorityQueue的排序规则？

自定义排序规则是

PriorityQueue

登录后复制

非常实用的一个特性，也是我个人觉得它魅力所在的地方。Java提供了两种主要方式来实现这一点。

硅基智能

基于Web3.0的元宇宙，去中心化的互联网，高质量、沉浸式元宇宙直播平台，用数字化重新定义直播

查看详情

第一种是让你的元素类实现

Comparable

登录后复制

接口。如果你的对象有“自然顺序”，比如数字的大小、字符串的字典序，那么让它实现

Comparable

登录后复制

，并重写

compareTo

登录后复制

方法，

PriorityQueue

登录后复制

在创建时就会自动使用这个自然顺序。

class Student implements Comparable<Student> {
    String name;
    int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    // 假设分数越高优先级越高，所以是降序
    @Override
    public int compareTo(Student other) {
        return other.score - this.score; // 大顶堆，分数高的先出
    }

    @Override
    public String toString() {
        return "Student{" + "name='" + name + '\'' + ", score=" + score + '}';
    }
}

// 使用自然排序（即Student类中定义的compareTo）
PriorityQueue<Student> highScorers = new PriorityQueue<>();
highScorers.add(new Student("Alice", 90));
highScorers.add(new Student("Bob", 95));
highScorers.add(new Student("Charlie", 88));
System.out.println("最高分学生: " + highScorers.poll()); // Bob

登录后复制

第二种，也是更灵活的方式，是给

PriorityQueue

登录后复制

的构造函数传入一个

Comparator

登录后复制

对象。这种方式的好处是，你可以在不修改元素类的情况下，为同一个类定义多种排序规则。这在处理第三方库的类或者需要动态改变排序逻辑时特别有用。

// 使用Lambda表达式定义Comparator，实现按名字长度排序（短的优先）
PriorityQueue<String> byLength = new PriorityQueue<>(Comparator.comparingInt(String::length));
byLength.add("apple");
byLength.add("banana");
byLength.add("cat");
System.out.println("按长度排序: " + byLength.poll()); // cat

// 或者，如果想实现大顶堆（最大值优先），可以这样
PriorityQueue<Integer> customMaxHeap = new PriorityQueue<>((a, b) -> b - a);
customMaxHeap.add(10);
customMaxHeap.add(20);
customMaxHeap.add(5);
System.out.println("自定义大顶堆: " + customMaxHeap.poll()); // 20

登录后复制

我个人偏爱使用

Comparator

登录后复制

，特别是Java 8引入Lambda表达式后，写起来简直不要太方便，代码也更简洁明了。它把排序逻辑和数据结构本身的创建清晰地分开了，这在维护大型项目时尤其重要。

PriorityQueue在哪些实际场景中能发挥巨大作用？

说起

PriorityQueue

登录后复制

的应用场景，那可真是太广了，很多算法和系统设计都离不开它。在我看来，它就是那种“看着不起眼，但一用起来就离不开”的数据结构。

一个经典的例子是Dijkstra最短路径算法。在寻找图中两点间最短路径时，我们总是需要优先处理那些当前已知路径最短的节点。

PriorityQueue

登录后复制

就能完美地存储这些待处理的节点，并根据它们的当前最短距离进行排序，每次取出距离最小的节点进行扩展。没有它，Dijkstra算法的效率会大打折扣。

再比如，任务调度系统。想象一下，你有一堆任务，每个任务都有一个优先级或者一个计划执行时间。你需要一个调度器，总是能把当前最紧急或者最先到期的任务拿出来执行。

PriorityQueue

登录后复制

在这里就能大显身手，它能确保你总是能高效地获取到下一个需要执行的任务。

还有，“Top K”问题。比如从海量数据中找出最大的K个元素，或者最小的K个元素。这时，我们可以维护一个大小为K的

PriorityQueue

登录后复制

。如果是找最大的K个，就用一个小顶堆，遍历数据时，如果当前元素比堆顶元素大，就替换掉堆顶。如果是找最小的K个，就用一个大顶堆，逻辑类似。这种方法比直接排序整个数据集要高效得多，尤其是在数据量巨大的时候。

// 找出数组中最大的K个元素 (使用小顶堆)
int[] nums = {3, 2, 1, 5, 6, 4};
int k = 3;
PriorityQueue<Integer> topKHeap = new PriorityQueue<>(); // 默认小顶堆

for (int num : nums) {
    topKHeap.offer(num);
    if (topKHeap.size() > k) {
        topKHeap.poll(); // 移除最小的，保持堆中是当前遇到的K个最大元素
    }
}
System.out.println("最大的K个元素: " + topKHeap); // [4, 5, 6] (内部顺序不保证，但poll会按从小到大)

登录后复制

这个例子就很好的说明了，利用