1. 从一次线上事故说起：为什么需要区分 == 和 equals()
去年我在处理一个电商平台的优惠券系统时，遇到过这样一个生产问题：用户领取的满100减20优惠券，在结算时突然全部失效。经过紧急排查，发现问题出在这样一段代码：
java复制String couponCodeFromDB = "DISCOUNT100"; // 数据库存储的优惠券码
String couponCodeFromRequest = new String("DISCOUNT100"); // 用户请求中的优惠券码
if (couponCodeFromDB == couponCodeFromRequest) { // 错误的使用方式
applyDiscount();
}
这段代码看起来逻辑很简单——比较两个字符串是否相同。但实际运行时，即使两个字符串内容完全一致，条件判断却总是返回false。这就是典型的混淆了==和equals()的案例。
2. 本质区别：身份 vs 内容
2.1 == 操作符的底层逻辑
==是Java中最基础的比较运算符，它的行为在JVM规范中有明确定义：
-
对于基本数据类型（int, char, boolean等）：直接比较值是否相等
java复制int a = 5; int b = 5; System.out.println(a == b); // true -
对于引用类型：比较对象的内存地址是否相同
java复制String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1 == s2); // false
关键理解：
==判断的是"这两个变量是否指向堆内存中的同一个对象"，就像比较两个人的身份证号是否相同。
2.2 equals() 方法的契约
equals()是Object类定义的方法，其默认实现就是==比较：
java复制public boolean equals(Object obj) {
return (this == obj);
}
但Java设计者允许（也鼓励）子类重写这个方法，实现"业务意义上的相等"。以String类为例，它的equals()实现如下：
java复制public boolean equals(Object anObject) {
if (this == anObject) { // 先做地址比较
return true;
}
if (anObject instanceof String) { // 类型检查
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) { // 长度比较
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) { // 逐个字符比较
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
这个实现体现了equals()方法的通用规范：
- 自反性：x.equals(x)必须为true
- 对称性：x.equals(y)与y.equals(x)结果相同
- 传递性：如果x.equals(y)且y.equals(z)，则x.equals(z)
- 一致性：多次调用结果不变（前提是对象未修改）
- 非空性：x.equals(null)必须返回false
3. 典型场景深度分析
3.1 字符串比较的陷阱
java复制String s1 = "java";
String s2 = "java";
String s3 = new String("java");
String s4 = new String("java");
System.out.println(s1 == s2); // true - 字符串常量池优化
System.out.println(s1 == s3); // false
System.out.println(s3 == s4); // false
System.out.println(s3.equals(s4)); // true
这里涉及Java字符串常量池的机制：
- 直接赋值的字符串字面量会进入常量池
- new String()会在堆中创建新对象
- intern()方法可以手动将字符串放入常量池
3.2 包装类(Integer等)的特殊情况
java复制Integer a = 127;
Integer b = 127;
Integer c = 128;
Integer d = 128;
System.out.println(a == b); // true
System.out.println(c == d); // false
这是因为Integer在-128~127范围内使用了缓存（通过IntegerCache内部类实现），超出此范围则每次new新对象。
3.3 自定义对象的equals实现
假设我们有一个User类：
java复制class User {
private Long id;
private String username;
// 错误示范：未重写equals
// 正确做法：
@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(username, user.username);
}
@Override
public int hashCode() {
return Objects.hash(id, username);
}
}
重要规则：重写equals()必须同时重写hashCode()，否则会导致HashSet/HashMap等集合类工作异常
4. 面试高频问题解析
4.1 为什么String的equals()要先比较引用？
这是一种性能优化——如果两个对象内存地址相同，直接返回true，避免后续的字符逐个比较。
4.2 equals()与hashCode()的关系
根据Java规范：
- 如果两个对象equals()为true，它们的hashCode()必须相同
- 但hashCode()相同，equals()不一定为true
违反这一规则会导致HashMap等集合无法正确工作。例如：
java复制User u1 = new User(1L, "Alice");
User u2 = new User(1L, "Alice");
Set<User> users = new HashSet<>();
users.add(u1);
System.out.println(users.contains(u2)); // 如果未正确重写hashCode，可能返回false
4.3 如何安全地实现equals()
推荐使用Java 7+的Objects工具类：
java复制@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof MyClass)) return false;
MyClass other = (MyClass) o;
return Objects.equals(field1, other.field1) &&
Objects.equals(field2, other.field2);
}
5. 性能优化与最佳实践
5.1 比较顺序优化
在实现equals()时，应该：
- 先比较引用（==检查）
- 再比较类型（instanceof）
- 最后比较字段（从计算成本低的字段开始）
java复制@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Product)) return false;
Product p = (Product) o;
// 先比较简单的数值字段
if (id != p.id) return false;
// 最后比较复杂的对象字段
return Objects.equals(name, p.name);
}
5.2 不可变对象的缓存技巧
对于频繁比较的值对象，可以：
java复制class Color {
private final String name;
private static final Map<String, Color> CACHE = new HashMap<>();
public static Color valueOf(String name) {
return CACHE.computeIfAbsent(name, Color::new);
}
private Color(String name) {
this.name = name;
}
// 现在可以直接用==比较
Color red1 = Color.valueOf("red");
Color red2 = Color.valueOf("red");
System.out.println(red1 == red2); // true
}
5.3 记录类(Record)的自动实现
Java 14引入的Record类型会自动生成规范的equals()和hashCode()：
java复制record Point(int x, int y) {}
Point p1 = new Point(1, 2);
Point p2 = new Point(1, 2);
System.out.println(p1.equals(p2)); // true
6. 常见误区与排查技巧
6.1 空指针异常防护
比较时总是把已知非空对象放在前面：
java复制// 不安全
"hello".equals(someString);
// 更安全
Objects.equals("hello", someString);
6.2 继承体系的equals难题
考虑这个类层次：
java复制class Animal {
private String species;
// equals实现比较species
}
class Dog extends Animal {
private String breed;
// 如何正确实现equals？
}
解决方案：
- 用getClass()代替instanceof确保类型严格匹配
- 或者使用组合代替继承
6.3 调试技巧
在IDEA中可以：
- 右键点击equals()调用
- 选择"Evaluate Expression"
- 查看比较过程的每一步结果
对于复杂的对象比较，可以重写toString()方法，方便调试时查看对象内容。