PriorityQueue是Java中基于优先级出队的队列，默认为小顶堆，每次取出最小元素；其核心方法包括add/offer入队、poll出队、peek查看队首；与普通FIFO队列不同，它按元素优先级排序而非入队顺序；可通过实现Comparable接口或传入Comparator自定义排序规则；常用于Dijkstra算法、任务调度、Top K问题等需动态处理最高优先级元素的场景。
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提供了两种主要方式来实现这一点。
第一种是让你的元素类实现
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会按从小到大)这个例子就很好的说明了，利用
PriorityQueue的特性，我们能以相对高效的方式解决一些看似复杂的问题。
此外，事件模拟系统、霍夫曼编码（Huffman Coding）构建最小生成树等算法中，
PriorityQueue也扮演着核心角色。它提供了一种高效管理“按优先级处理”元素的机制，让复杂的问题变得清晰和可操作。所以，掌握
PriorityQueue的使用，对于解决很多实际的编程挑战来说，绝对是一项非常值得投资的技能。
