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

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提供了两种主要方式来实现这一点。

菜鸟学PHP之Smarty入门

　　刚开始接触模版引擎的 PHP 设计师，听到 Smarty 时，都会觉得很难。其实笔者也不例外，碰都不敢碰一下。但是后来在剖析 XOOPS 的程序架构时，开始发现 Smarty 其实并不难。只要将 Smarty 基础功练好，在一般应用上就已经相当足够了。当然基础能打好，后面的进阶应用也就不用怕了。　　这篇文章的主要用意并非要深入探讨 Smarty 的使用，这在官方使用说明中都已经写得很完整了。笔

385

查看详情

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

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会按从小到大)

登录后复制

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