1. Comparable 与 compareTo
1.1 返回值的含义
this.compareTo(other) 的返回值决定排序结果:
| 返回值 | 排序效果 |
|---|---|
this.compareTo(other) < 0 | this 排在 other 前面 |
this.compareTo(other) == 0 | this 与 other 顺序相同 |
this.compareTo(other) > 0 | this 排在 other 后面 |
至于是升序还是降序,取决于你如何定义 compareTo 方法。具体解释如下:
class Num implements Comparable<Num> {
final int v;
Num(int v) { this.v = v; }
// 版本 A:升序(自然序)
public int compareTo(Num other) {
return this.v - other.v;
}
// 版本 B:降序(只把减法翻过来,其余一字不动)
// public int compareTo(Num other) {
// return other.v - this.v;
// }
}
两种定义对应两种结果:
- 方法体是
this.v - other.v:调用this.compareTo(other)时,this比较小则差值为负数,this在前,最终表现为升序。 - 方法体是
other.v - this.v:调用this.compareTo(other)时,this比较小则差值为正数,this在后,最终表现为降序。
注意: 永远执行的是 this.compareTo(other),是根据结果确定 this 的位置,不要考虑所谓的 other.compareTo(this)。即使这样考虑,other.compareTo(this) 里的 other 也是 this,因为永远是当前对象调用 compareTo。所以理解成永远都是 this.compareTo(other) 就可以了。
1.2 需要遵守的约定
- 反对称:
x.compareTo(y)返回正数,则y.compareTo(x)必须返回负数。 - 传递性: 若
x > y、y > z,则x > z。 - 一致性: 若
x.compareTo(y) == 0,则x.compareTo(z)与y.compareTo(z)的符号必须相同。 - 建议(非强制):
x.compareTo(y) == 0时,x.equals(y) == true也应成立。
第 4 条为什么重要:如果 x.compareTo(y) == 0 而 x.equals(y) == false,那么在那些利用 compareTo == 0 判断两个元素是否相同的集合中,就会把它们当成同一个元素;如果是 Set,最终只会保留一个。
举例: Java 的 BigDecimal 在 x.compareTo(y) == 0 时并不保证 x.equals(y) == true。1.0 和 1.00 用 compareTo 比较结果是 0,用 equals 比较结果是 false。而 TreeSet 按 compareTo == 0 认定两个元素相同,所以 1.0 和 1.00 放入 TreeSet 只会留下一个。
1.3 注意事项
1.3.1 减法溢出:用 Integer.compare(a, b) 代替 a - b
比较时用 Integer.compare(a, b),而不是 a - b,因为 a - b 有可能超出类型所能表达的范围,导致符号反转。比如 a = Integer.MAX_VALUE、b = -1 时,a - b 反而等于 Integer.MIN_VALUE。
我们其实只需要返回正数 / 0 / 负数,返回的数值大小没有用(-1 和 -100 表示的意思一样)。Integer.compare(a, b) 内部就是这样做的:不用加减法,而是直接用大于、小于号比较 a 和 b 的大小。
1.3.2 多字段比较:不等则返回,相等则比较下一个字段
多字段比较的方式:不等则返回,相等则比较下一个字段。
1.3.3 compareTo、equals 与 hashCode 的一致性
a)compareTo 返回 0 时,equals 也要返回 true。 也就是说,一个类实现 Comparable 接口时,除了要重写 compareTo 方法,还要重写 equals 方法。为什么这么做,前面(1.2 第 4 条)已经说了。
b)重写了 equals,就要重写 hashCode。 因为必须保证 a.equals(b) 返回 true 时,a.hashCode() 要等于 b.hashCode()。这是 Java 中的一个硬性规定。
为什么要这样?举个例子:我们对 User 类重写了 equals 方法,认为 name 相同就返回 true,但没有重写 hashCode 方法。此时有两个 User 对象 user1 和 user2,name 相同,只把 user1 放入 HashMap(map.put(user1, 'szhang')),用 user2 去查是查不到的,map.get(user2) 返回 null。HashMap.get(key) 的大致过程如下:
- 算 hashCode 定位桶。
- 进入对应的桶。
- 对桶里的节点,先比较 hashCode,再用 equals 确认。
用 user2 去查时,定位到的桶大概率不是存放 user1 的桶,所以会找不到。重写 hashCode 方法能解决这个问题:让 name 相同时 hashCode 也相同,map.get(user2) 就能查到 'szhang'。
这只是一条规则,真正要怎么实践呢?比如:
a)对于 String
Student a = new Student("Bob", 20, 3.5); // 常量池里的 "Bob"
Student b = new Student(new String("Bob"), 20, 3.5); // 堆上新建的 "Bob"
a.compareTo(b); // 0 —— 内容相同
a.equals(b); // false —— 引用不同
a.name.compareTo(b.name) 返回的是 0,但 a.name == b.name 返回的是 false,必须使用 a.name.equals(b.name) 才返回 true。
== 比较的是引用地址是否相同,equals 比较的是引用所指向对象的内容是否相同。
b)对于 double
compareTo 和 == 的语义是不一样的。比如 NaN 表示"不是任何值",两个 NaN 用 compareTo 比较会得到 0,但用 == 比较返回 false。所以要想在 compareTo == 0 时让 equals 也返回 true,可以直接在 equals 方法里调用 Double.compare(a, b)。
1.4 实现了 Comparable 接口后怎么用
只要你的类实现了 Comparable 接口,那么在那些本身需要维持顺序的容器里,或者需要回答"谁在前谁在后"的时候,就会用到它。
比如 Collections.sort(list) 方法,排序时会回调 list 中元素对应类重写后的 compareTo 方法。
1.5 总结
(1)返回值只看符号
compareTo 返回值的符号表示顺序,返回值的大小没有意义。
(2)四条契约
a.compareTo(b)的符号与b.compareTo(a)的符号相反。- 若
a > b、b > c,则a > c。 - 若
a.compareTo(b) == 0,则a.compareTo(c)和b.compareTo(c)的符号是一样的。 a.compareTo(b) == 0与a.equals(b) == true最好同时成立。
(3)三个注意事项
- 减法溢出问题。
- 多字段比较。
- 重写了 equals 就要重写 hashCode 方法,要保证 equals 返回 true 时 hashCode 相等。
2. Comparator
2.1 Comparator 是什么
Comparable 是把比较能力放在对象内部。
Comparator 是把比较能力独立成一个对象。这样做有两点好处:
- 可以让一个类有多种排序规则——一种规则写一个 Comparator;Comparable 做不到,因为一个类实现 Comparable 之后,只能在 compareTo 方法中实现一种比较逻辑。
- 实现比较规则时不需要改动类的源码——比较规则独立成一个对象;Comparable 做不到。比如 String 类,JDK 中已经写好了按字典序排序的 compareTo 方法,想按字符数排序,只能自己实现 Comparator 接口。
2.2 五种写法
2.2.1 五种写法一览
第一类:基础写法
// 1. 显式创建类实现 Comparator 接口
public class StudentComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return Integer.compare(o1.getAge(), o2.getAge());
}
}
// 2. 匿名内部类
Comparator<Student> byAge = new Comparator<Student>() {
@Override
public int compare(Student a, Student b) {
return Integer.compare(a.age(), b.age());
}
};
// 3. lambda 表达式
Comparator<Student> byAge = (a, b) -> Integer.compare(a.age(), b.age());
第二类:静态工厂方法 + 方法引用
Comparator<Student> byAge = Comparator.comparingInt(Student::age);
// 多级排序
Comparator<Student> byAgeThenName = Comparator.comparingInt(Student::age)
.thenComparing(Student::name);
2.2.2 如何从基础写法演化为静态工厂方法
2.2.2.1 什么是静态工厂方法
用 static 修饰、用来构造并返回实例的方法,就是静态工厂方法,用来替代 new 构造器。
静态工厂方法很常见,比如 LocalDate.of、List.of、String.valueOf。
2.2.2.2 演变
观察下面这几个 lambda 形式的写法:
(a, b) -> Integer.compare(a.age, b.age)
(a, b) -> Integer.compare(a.score, b.score)
(a, b) -> Integer.compare(a.xxx, b.xxx)
不变的是整个逻辑: 取出比较键,执行 Integer.compare,返回 Comparator。
变的是取哪个键作为比较键。 于是把不变的部分放进 JDK,做成返回 Comparator 的工厂方法,参数改成取比较键的方法。
注意: 取比较键的方法又是一个函数式接口。
2.3 comparing 的变体
comparing 是一个通用的静态工厂方法,它还有一些变体,比如 comparingInt、comparingDouble、comparingLong。
在性能敏感的场景,优先使用 comparingInt 这类变体,优势是可以省掉大量的装箱。
如何理解这一点?
comparing内部:把左右两个元素的 key 取出来,然后执行key1.compareTo(key2)。comparingInt内部:不用 key 自己比,直接对两个裸数字执行Integer.compare(a, b)。
如果 comparing 内部提取出来的 key 是裸数字,裸数字没有 compareTo 方法,需要装箱成 Integer;大量元素两两比较,就需要大量的装箱操作。
2.4 降序
reversed() 反转的是它前面已经组合好的整条链。
// A:先组合,最后反转
Comparator.comparingInt(Student::age)
.thenComparing(Student::name)
.reversed();
// 结果:年龄降序,年龄相同则姓名【降序】—— 整条链都被翻过来了
// B:反转第一个字段,再接第二个
Comparator.comparingInt(Student::age).reversed()
.thenComparing(Student::name);
// 结果:年龄降序,年龄相同则姓名【升序】—— 这通常才是你想要的
2.5 null 值的处理
情况 1:元素本身就是 null(列表里有 null 项)
list.sort(Comparator.nullsFirst(Comparator.naturalOrder())); // null 排最前
list.sort(Comparator.nullsLast(Comparator.naturalOrder())); // null 排最后
情况 2:元素不是 null,但比较键是 null
这时要用 comparing 的两参数版本:参数 1 指明提取键的方法,参数 2 指明键的排序规则。比如 Student 中有 gpa,gpa 有可能是 null,要按 gpa 倒序排序:
Comparator<Double> gpaRule = Comparator.nullsLast(Comparator.reverseOrder());
Comparator<Student> c = Comparator.comparing(Student::gpa, gpaRule);
2.6 在哪里传 Comparator
- 本身需要顺序的集合。
- 对集合中的元素按照某种自定义顺序排序。
3. Comparable 和 Comparator 什么时候用哪个
- 类是你写的,且存在一个"所有人都认的默认顺序" → 用
Comparable(implements Comparable)。典型是值对象:金额、版本号、日期。 - 其余全部情况 → 用
Comparator:需要多种顺序、临时顺序、给改不了源码的类排序、顺序依赖外部参数(如按当前用户的语言)。
4. compareTo 与 equals 不一致时的行为对照
| 操作 | 判等 / 比较依据 |
|---|---|
| HashSet / HashMap 的 add、put、contains | hashCode + equals |
| TreeSet / TreeMap 的 add、put、contains | compare() == 0,完全不看 equals |
| List.contains / indexOf / remove(Object) | equals |
| List.sort / Arrays.sort / stream.sorted() | compareTo / compare |
| Collections.binarySearch | compare,且必须与排序时同一规则 |
| stream.distinct() | equals + hashCode |