Java 对象比较涉及 equals、Comparable 和 Comparator 三种方式。equals 判断逻辑相等，Comparable 定义自然排序，Comparator 提供外部定制排序。PriorityQueue 依赖这些机制管理元素优先级。详解三者区别、实现规范及在 PriorityQueue 中的应用，并通过 Top-K 问题实战展示堆的使用技巧与 Lambda 简化写法。
在 Java 编程中，我们经常需要对对象进行比较操作。对于基本数据类型，可以直接使用 >、<、== 等运算符进行比较，但对于对象，情况则复杂得多。特别是在使用某些集合框架时（如 PriorityQueue），对象之间的比较能力成为必须掌握的技能。
考虑这样一个场景：我们需要管理一副扑克牌，并按照牌面大小进行排序或优先级处理。如何让 Java 理解"红桃 A 比黑桃 K 大"这样的业务逻辑？这正是对象比较要解决的核心问题。
Java 的基本类型（int、char、boolean 等）可以直接使用关系运算符进行比较：
int a = 10, b = 20;
System.out.println(a > b); // false
System.out.println(a < b); // true
System.out.println(a == b); // false
char c1 = 'A', c2 = 'B';
System.out.println(c1 < c2); // true
boolean b1 = true, b2 = false;
System.out.println(b1 == b2); // false
对于自定义的引用类型，直接使用关系运算符会导致编译错误：
class Card {
public int rank; // 数值
public String suit; // 花色
public Card(int rank, String suit) {
this.rank = rank;
this.suit = suit;
}
}
public class Test {
public static void main(String[] args) {
Card c1 = new Card(1, "♠");
Card c2 = new Card(2, "♥");
// System.out.println(c1 > c2); // 编译错误！
// System.out.println(c1 < c2); // 编译错误！
System.out.println(c1 == c2); // 比较地址，返回 false
}
}
关键点：== 对于引用类型比较的是内存地址，而不是对象内容。即使两个 Card 对象的 rank 和 suit 完全相同，== 也会返回 false。
所有 Java 类都隐式继承自 Object 类，Object 类中的 equals 方法默认实现如下：
public boolean equals(Object obj) {
return (this == obj); // 比较地址！
}
要比较对象内容，必须在自定义类中覆写 equals 方法：
class Card {
public int rank;
public String suit;
public Card(int rank, String suit) {
this.rank = rank;
this.suit = suit;
}
@Override
public boolean equals(Object o) {
// 1. 检查是否是同一个对象
if (this == o) return true;
// 2. 检查是否为 null 或类型不匹配
if (o == null || getClass() != o.getClass()) return false;
// 3. 类型转换
Card card = (Card) o;
// 4. 比较关键字段
return rank == card.rank && suit.equals(card.suit);
}
// 良好的实践：覆写 equals 时也应覆写 hashCode
@Override
public int hashCode() {
return Objects.hash(rank, suit);
}
}
if (this == obj) return true;if (obj == null) return false;if (getClass() != obj.getClass()) return false;局限性：equals 只能判断"相等与否"，无法判断"大小关系"。
public interface Comparable<T> {
// 返回值：
// < 0: this < other
// = 0: this == other
// > 0: this > other
int compareTo(T o);
}
class Card implements Comparable<Card> {
public int rank;
public String suit;
public Card(int rank, String suit) {
this.rank = rank;
this.suit = suit;
}
@Override
public int compareTo(Card o) {
// 处理 null 值（通常将 null 视为最小）
if (o == null) {
return 1; // this > null
}
// 主要按数值比较，数值相同则按花色
if (this.rank != o.rank) {
return this.rank - o.rank; // 升序排列
}
// 数值相同，比较花色
return this.suit.compareTo(o.suit);
}
}
public class Test {
public static void main(String[] args) {
Card card1 = new Card(5, "♠");
Card card2 = new Card(3, "♥");
Card card3 = new Card(5, "♣");
System.out.println(card1.compareTo(card2)); // > 0 (5 > 3)
System.out.println(card1.compareTo(card3)); // > 0 ("♠" > "♣")
System.out.println(card2.compareTo(card1)); // < 0 (3 < 5)
}
}
特点：Comparable 是"内部比较器"，定义了对象的自然排序顺序。
public interface Comparator<T> {
int compare(T o1, T o2);
}
import java.util.Comparator;
// 按数值降序排列的比较器
class RankDescComparator implements Comparator<Card> {
@Override
public int compare(Card o1, Card o2) {
// 处理 null 值
if (o1 == o2) return 0;
if (o1 == null) return -1; // null 较小
if (o2 == null) return 1; // null 较小
// 降序排列：o2.rank - o1.rank
return o2.rank - o1.rank;
}
}
// 按花色优先的比较器
class SuitFirstComparator implements Comparator<Card> {
@Override
public int compare(Card o1, Card o2) {
if (o1 == o2) return 0;
if (o1 == null) return -1;
if (o2 == null) return 1;
// 先比较花色
int suitCompare = o1.suit.compareTo(o2.suit);
if (suitCompare != ) {
suitCompare;
}
o1.rank - o2.rank;
}
}
public class Test {
public static void main(String[] args) {
Card c1 = new Card(5, "♠");
Card c2 = new Card(3, "♥");
Card c3 = new Card(5, "♣");
Comparator<Card> rankDescComp = new RankDescComparator();
Comparator<Card> suitFirstComp = new SuitFirstComparator();
System.out.println(rankDescComp.compare(c1, c2)); // < 0 (降序：5 < 3)
System.out.println(suitFirstComp.compare(c1, c3)); // > 0 ("♠" > "♣")
}
}
特点：Comparator 是"外部比较器"，可以为同一个类定义多种排序规则。
| 比较方式 | 所属包 | 方法名 | 特点 | 使用场景 |
|---|---|---|---|---|
| equals | java.lang.Object | equals() | 只能比较相等性，不能比较大小 | 判断两个对象是否逻辑相等 |
| Comparable | java.lang | compareTo() | 内部比较器，定义自然顺序 | 类有明确的默认排序规则 |
| Comparator | java.util | compare() | 外部比较器，灵活定义多种规则 | 需要多种排序方式，或无法修改类源码 |
设计原则：
PriorityQueue（优先级队列）底层基于堆实现，要求所有元素必须能够比较大小。当插入自定义对象时，必须提供比较方式。
// 错误示例：Card 未实现 Comparable
PriorityQueue<Card> queue = new PriorityQueue<>();
queue.offer(new Card(1, "♠")); // 抛出 ClassCastException！
class Card implements Comparable<Card> {
// ... 同上实现
@Override
public int compareTo(Card o) {
return this.rank - o.rank;
}
}
// 使用默认比较（小根堆）
PriorityQueue<Card> queue = new PriorityQueue<>();
queue.offer(new Card(5, "♠"));
queue.offer(new Card(3, "♥"));
queue.offer(new Card(8, "♣"));
System.out.println(queue.poll().rank); // 3（最小）
System.out.println(queue.poll().rank); // 5
System.out.println(queue.poll().rank); // 8
// Card 类不需要实现 Comparable
class Card {
public int rank;
public String suit;
// ... 构造方法等
}
// 自定义比较器：创建大根堆
class CardComparator implements Comparator<Card> {
@Override
public int compare(Card o1, Card o2) {
return o2.rank - o1.rank; // 降序：大根堆
}
}
// 使用自定义比较器
PriorityQueue<Card> maxHeap = new PriorityQueue<>(new CardComparator());
maxHeap.offer(new Card(5, "♠"));
maxHeap.offer(new Card(3, "♥"));
maxHeap.offer(new Card(8, "♣"));
System.out.println(maxHeap.poll().rank); // 8（最大）
System.out.println(maxHeap.poll().rank); // 5
System.out.println(maxHeap.poll().rank); // 3
PriorityQueue 内部维护了一个比较器对象，根据用户是否提供比较器决定使用哪种比较方式：
// PriorityQueue 简化源码
public class PriorityQueue<E> {
private final Comparator<? super E> comparator;
// 构造方法 1：使用默认比较（依赖 Comparable）
public PriorityQueue() {
this(DEFAULT_INITIAL_CAPACITY, null);
}
// 构造方法 2：使用自定义比较器
public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {
// ...
this.comparator = comparator;
}
// 插入时的调整方法
private void siftUp(int k, E x) {
if (comparator != null) {
siftUpUsingComparator(k, x); // 使用 Comparator
} else {
siftUpComparable(k, x); // 使用 Comparable
}
}
}
Top-K 问题：从 N 个元素中找出最大（或最小）的 K 个元素。使用堆可以高效解决，时间复杂度为 O(NlogK)。
解决思路（以找最小的 K 个数为例）：
- 用前 K 个元素构建一个"大根堆"（堆顶是 K 个数中的最大值）
- 遍历剩余 N-K 个元素： a. 如果当前元素 < 堆顶元素（即比 K 个数中的最大值还小） b. 替换堆顶元素，并调整堆
- 遍历完成后，堆中的 K 个元素就是最小的 K 个数
import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
public class TopKProblem {
// 比较器 1：创建小根堆
static class MinHeapComparator implements Comparator<Integer> {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2; // 升序：小根堆
}
}
// 比较器 2：创建大根堆
static class MaxHeapComparator implements Comparator<Integer> {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1; // 降序：大根堆
}
}
/**
* 查找数组中最小的 K 个数
* @param arr 输入数组
* @param k 需要查找的元素个数
* @return 最小的 K 个数组成的数组
*/
public static int[] findSmallestK(int[] arr, int k) {
// 边界检查
if (arr == null || k <= 0 || k > arr.length) {
return new int[0];
}
// 创建大根堆（存储最小的 K 个数，堆顶是这 K 个数中的最大值）
PriorityQueue<Integer> maxHeap = <>(k, ());
( ; i < k; i++) {
maxHeap.offer(arr[i]);
}
( k; i < arr.length; i++) {
arr[i];
maxHeap.peek();
(current < heapMax) {
maxHeap.poll();
maxHeap.offer(current);
}
}
[] result = [k];
( ; i < k; i++) {
result[i] = maxHeap.poll();
}
result;
}
[] findLargestK([] arr, k) {
(arr == || k <= || k > arr.length) {
[];
}
PriorityQueue<Integer> minHeap = <>(k, ());
( ; i < k; i++) {
minHeap.offer(arr[i]);
}
( k; i < arr.length; i++) {
arr[i];
minHeap.peek();
(current > heapMin) {
minHeap.poll();
minHeap.offer(current);
}
}
[] result = [k];
( ; i < k; i++) {
result[i] = minHeap.poll();
}
result;
}
{
[] array = {, , , , , , , , , };
;
[] smallestK = findSmallestK(array, k);
System.out.println( + k + + Arrays.toString(smallestK));
[] largestK = findLargestK(array, k);
System.out.println( + k + + Arrays.toString(largestK));
}
}
建堆：O(K) 遍历剩余元素并调整：O((N-K) log K) 总复杂度：O(N log K)
// 使用 Lambda 创建比较器
public static int[] findSmallestKLambda(int[] arr, int k) {
if (arr == null || k <= 0 || k > arr.length) {
return new int[0];
}
// 大根堆：使用 Lambda 表达式
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(
k, (a, b) -> b - a // 等价于 new MaxHeapComparator()
);
// 或者使用方法引用
// PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
// ... 剩余代码相同
}
避免整型溢出：
// 错误：可能溢出
// return o1.rank - o2.rank;
// 正确：使用 Integer.compare
return Integer.compare(o1.rank, o2.rank);
初始化容量：如果知道元素数量，建议指定初始容量
// 推荐
PriorityQueue<Integer> pq = new PriorityQueue<>(expectedSize);
import java.util.*;
class Student {
private String name;
private int score;
private String className;
public Student(String name, int score, String className) {
this.name = name;
this.score = score;
this.className = className;
}
// 自然排序：按成绩降序
public static class ScoreComparator implements Comparator<Student> {
@Override
public int compare(Student s1, Student s2) {
return Integer.compare(s2.score, s1.score); // 降序
}
}
// 按班级排序，同班级按成绩
public static class ClassScoreComparator implements Comparator<Student> {
@Override
public int compare(Student s1, Student s2) {
int classCompare = s1.className.compareTo(s2.className);
if (classCompare != 0) {
return classCompare;
}
return Integer.compare(s2.score, s1.score);
}
}
@Override
String {
String.format(, name, className, score);
}
{
List<Student> students = Arrays.asList(
(, , ),
(, , ),
(, , ),
(, , )
);
PriorityQueue<Student> scoreQueue = <>( ());
scoreQueue.addAll(students);
System.out.println();
(!scoreQueue.isEmpty()) {
System.out.println(scoreQueue.poll());
}
PriorityQueue<Student> classQueue = <>( ());
classQueue.addAll(students);
System.out.println();
(!classQueue.isEmpty()) {
System.out.println(classQueue.poll());
}
}
}
Java 对象比较是面向对象编程中的重要概念，特别是在使用集合框架时。通过本文的学习，你应该掌握：
equals：判断逻辑相等Comparable：定义自然排序（内部比较器）Comparator：定义多种排序规则（外部比较器）
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online