Java 对象比较详解
引言
对象比较是 Java 编程中基础且核心的能力,它直接关系到集合元素的查找、排序、去重,以及业务逻辑中对象相等性的判断,是保证程序逻辑正确性和数据一致性的关键环节。
基本元素比较
Java 中基本元素(基本数据类型 + 对应的包装类 + 常用引用类型如 String)的比较规则,可以总结为以下核心要点:
1. 基本数据类型:直接用 == 比较值
Java 的 8 种基本数据类型(byte、short、int、long、float、double、char、boolean),只能用 == 比较值是否相等,不存在 equals() 方法。
int a = 10;
int b = 10;
System.out.println(a == b);
- 注意:不同基本类型比较时会发生自动类型提升,比如
int 和 long 比较,int 会提升为 long 后再比。
2. 包装类:分两种情况
包装类(Integer、Long、Boolean 等)是引用类型,但有常量池缓存机制,比较规则需区分场景:
| 比较方式 | 适用场景 | 规则说明 |
|---|
== | 缓存范围内的包装类对象 | 对于 Integer(-128 ~ 127)、Boolean(true/false)等,缓存池内的对象用 == 会返回 true |
== | 缓存范围外的包装类对象 | 会创建新对象,== 比较的是地址,返回 false |
equals() | 所有包装类对象 | 比较的是底层基本类型的值,推荐使用 |
示例:
Integer i1 = 127;
Integer i2 = 127;
System.out.println(i1 == i2);
System.out.println(i1.equals(i2));
Integer i3 = 128;
Integer i4 = 128;
System.out.println(i3 == i4);
System.out.println(i3.equals(i4));
3. String 类型:核心看 == 和 equals() 的区别
String 是引用类型,且有字符串常量池,比较规则是 Java 面试高频考点:
==:比较的是对象的内存地址
- 直接赋值的字符串(如
String s = "abc")会存入常量池,相同内容的字符串指向同一个地址。
new 创建的字符串(如 String s = new String("abc"))会在堆中创建新对象,地址不同。
equals():重写过的方法,比较的是字符串的内容,推荐使用。
示例:
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s1.equals(s3));
基本元素比较的核心建议
- 基本数据类型:直接用
== 即可。
- 包装类和
String:优先用 equals() 比较内容,避免因缓存/常量池机制导致的逻辑错误。
包装类和基本类型混合比较:包装类会自动拆箱为基本类型,用 == 直接比的值。
Integer i = 10;
int j = 10;
System.out.println(i == j);
总结
- 对象比较的最佳实践总结
- 不同场景下的选择建议
- 未来 Java 版本中可能的改进
对象的比较
Java 中自定义对象的比较,核心围绕 内容相等性判断 和 大小关系排序 两大需求,对应四种实现方式,其中前三种是开发中最常用的:
1. 覆写基类 Object 的 equals() + hashCode()
核心用途
判断两个对象的内容是否相等,是集合去重、条件判断的基础。
核心规则
equals():默认比较对象地址(==),需重写为基于核心业务属性(如用户 ID、订单号)的比较逻辑。
hashCode():必须和 equals() 保持一致(规范要求:equals 相等的对象,hashCode 必须相同),否则 HashSet/HashMap 等哈希集合会失效。
实现要点
- 自反性:
x.equals(x) 必须返回 true。
- 对称性:
x.equals(y) 和 y.equals(x) 结果一致。
- 传递性:
x.equals(y) 且 y.equals(z),则 x.equals(z)。
- 一致性:对象属性不变时,多次调用
equals 结果不变。
- 非空性:
x.equals(null) 必须返回 false。
示例
public class User {
private Long id;
private String name;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return Objects.equals(id, user.id) && Objects.equals(name, user.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
}
适用场景
- 判断两个对象是否为'逻辑相等'(如判断两个用户是否是同一个人)。
- 作为
HashSet 元素、HashMap 的 key 时的必要操作。
2. 基于 Comparable 接口的比较
核心用途
定义对象的自然排序规则(默认排序规则),让对象'天生可比较'。
核心方法
实现 int compareTo(T o) 方法:
- 返回 正数:当前对象 > 目标对象。
- 返回 0:当前对象 = 目标对象。
- 返回 负数:当前对象 < 目标对象。
实现要点
- 排序规则基于业务核心属性(如按用户 ID 升序、按价格降序)。
- 需满足比较器一致性:
x.compareTo(y) == 0 应和 x.equals(y) 结果一致(非强制,但推荐遵守)。
示例
public class User implements Comparable<User> {
private Long id;
private String name;
@Override
public int compareTo(User o) {
return this.id.compareTo(o.id);
}
}
public class UserNameLengthComparator implements Comparator<User> {
@Override
public int compare(User u1, User u2) {
int len1 = u1.getName().length();
int len2 = u2.getName().length();
return len1 - len2;
}
}
List<User> userList = new ArrayList<>();
Collections.sort(userList, new UserNameLengthComparator());
Collections.sort 这个方法,其实有两种用法。第一种,只传一个 List,这时候 List 里的每个对象,必须自己会'比大小',也就是实现了 Comparable 接口,重写了 compareTo 方法。sort 方法会自动调用对象的 compareTo 来排顺序。第二种,传一个 List 再加一个 Comparator 比较器,这时候对象自己会不会比大小无所谓,sort 方法会用你传的比较器里的规则来排。简单说就是,不传比较器,就用对象自己的 compareTo;传了比较器,就听比较器的。
适用场景
- 对象有固定的默认排序规则(如用户默认按 ID 排序、商品默认按价格排序)。
- 用于
Collections.sort(List)、TreeSet/TreeMap 的默认排序。
3. 基于 Comparator 比较器的比较
核心用途
定义对象的定制排序规则,灵活扩展多种排序方式,不修改对象本身代码。
核心方法
实现 int compare(T o1, T o2) 方法,规则和 compareTo 一致。
实现形式
- 匿名内部类。
- Lambda 表达式(JDK 8+ 推荐)。
- 静态工具类(如
Comparator.comparing)。
示例
Comparator<User> nameLengthComparator = (u1, u2) -> Integer.compare(u2.getName().length(), u1.getName().length());
Comparator<User> nameComparator = Comparator.comparing(User::getName);
适用场景
- 对象需要多种排序规则(如用户可按 ID、姓名、注册时间排序)。
- 无法修改对象源码(如第三方类),但需要排序。
- 用于
Collections.sort(List, Comparator)、TreeSet 构造函数指定排序规则。
总结一下
| 比较方式 | 核心作用 | 灵活性 | 适用场景 |
|---|
equals() + hashCode() | 判断内容相等 | 低 | 集合去重、逻辑相等判断 |
Comparable | 自然排序(默认规则) | 低 | 对象有固定排序规则 |
Comparator | 定制排序(多规则) | 高 | 多种排序需求、第三方类排序 |
Objects.compare | 简化比较 + 空指针防护 | 中 | JDK 8+ 简洁排序代码 |
选型口诀:
- 判相等:重写
equals + hashCode。
- 单排序:实现
Comparable。
- 多排序:用
Comparator 比较器。