初学 Java 的朋友，甚至一些有经验的开发者，都可能在 == 和 equals() 这两种比较方式上栽过跟头。别担心！今天，我将带你深入剖析这两个“比较符”的奥秘，让你彻底搞懂 Java 对象比较。
1. == 操作符：内存地址的“守门员”
让我们从最基础的 == 操作符开始。它只关心两件事：
-
对于基本数据类型（如
int,char,boolean,float,double等）：==比较的是它们字面上的值。比如1 == 1肯定是true，3.14 == 3.15肯定是false。这很好理解，没啥可纠结的。 -
对于引用数据类型（如
String,Object, 自定义类等）：==比较的是两个引用变量是否指向内存中的同一个对象。换句话说，它看的是这两个变量存储的内存地址是否相同。
看几个例子来加深理解：
Java
String s1 = "hello"; // s1 指向常量池中的 "hello"
String s2 = "hello"; // s2 也指向常量池中的 "hello"
String s3 = new String("hello"); // s3 指向堆中新创建的 "hello" 对象
String s4 = s3; // s4 和 s3 指向同一个堆对象
System.out.println("s1 == s2: " + (s1 == s2)); // true，因为都指向常量池中的同一个 "hello"
System.out.println("s1 == s3: " + (s1 == s3)); // false，s1 指向常量池，s3 指向堆中的新对象
System.out.println("s3 == s4: " + (s3 == s4)); // true，s3 和 s4 引用的是内存中的同一个对象
为了更直观地理解:
2. equals() 方法：内容的“裁判员”
当我们需要比较两个对象的内容是否真正相等时，== 就显得力不从心了。这时候，equals() 方法就该登场了。
equals() 方法是 java.lang.Object 类中的一个方法。它的默认实现是这样的：
Java
public boolean equals(Object obj) {
return (this == obj); // 默认实现就是比较内存地址
}
这意味着，如果你不重写任何类的 equals() 方法，那么它的行为将和 == 完全一样——都只比较内存地址。
但 Java 中的很多核心类，比如 String、Integer、Date 等，都重写了 equals() 方法，让它能够比较对象的内容。这正是我们日常使用它们时，为什么 String 对象能按内容比较的原因。
Java
String str1 = "Java";
String str2 = new String("Java");
String str3 = "Java";
System.out.println("str1 == str2: " + (str1 == str2)); // false (内存地址不同)
System.out.println("str1.equals(str2): " + (str1.equals(str2))); // true (内容相同)
System.out.println("str1 == str3: " + (str1 == str3)); // true (字符串常量池优化)
System.out.println("str1.equals(str3): " + (str1.equals(str3))); // true (内容相同)
当你自定义类时：重写 equals() 的重要性
假设我们有一个 Student 类，我们希望当两个学生的姓名和学号都相同时，就认为他们是同一个学生。
如果不重写 equals() 方法：
class Student {
String name;
String studentId;
public Student(String name, String studentId) {
this.name = name;
this.studentId = studentId;
}
}
Student sA = new Student("张三", "2023001");
Student sB = new Student("张三", "2023001");
System.out.println("sA == sB: " + (sA == sB)); // false (两个不同的对象)
System.out.println("sA.equals(sB): " + (sA.equals(sB))); // false (默认 equals() 比较内存地址)
尽管 sA 和 sB 的姓名和学号都一样，但因为它们是内存中不同的对象，sA.equals(sB) 依然返回 false，这显然不符合我们的业务需求。
所以，我们需要重写 equals() 方法来定义我们自己的“相等”逻辑：
class StudentWithEquals {
String name;
String studentId;
public StudentWithEquals(String name, String studentId) {
this.name = name;
this.studentId = studentId;
}
@Override
public boolean equals(Object obj) {
// 1. 如果是同一个对象，直接返回 true
if (this == obj) {
return true;
}
// 2. 如果 obj 为 null 或者类型不一致，直接返回 false
if (obj == null || getClass() != obj.getClass()) {
return false;
}
// 3. 将 obj 强转为 StudentWithEquals 类型
StudentWithEquals other = (StudentWithEquals) obj;
// 4. 比较关键属性是否相等
return this.name.equals(other.name) &&
this.studentId.equals(other.studentId);
}
}
StudentWithEquals sC = new StudentWithEquals("李四", "2023002");
StudentWithEquals sD = new StudentWithEquals("李四", "2023002");
System.out.println("sC.equals(sD): " + (sC.equals(sD))); // true (内容相同，符合预期！)
重写 equals() 方法的规范（约定）：
在重写 equals() 方法时，需要遵循以下五个约定，以确保其行为正确和一致：
-
自反性 (Reflexive)：对于任何非
null的引用值x，x.equals(x)必须返回true。 -
对称性 (Symmetric)：对于任何非
null的引用值x和y，如果x.equals(y)返回true，那么y.equals(x)也必须返回true。 -
传递性 (Transitive)：对于任何非
null的引用值x、y和z，如果x.equals(y)返回true，并且y.equals(z)返回true，那么x.equals(z)也必须返回true。 -
一致性 (Consistent)：对于任何非
null的引用值x和y，只要equals比较中使用的信息没有被修改，那么对x.equals(y)的多次调用都必须返回相同的结果。 -
对于
null值：对于任何非null的引用值x，x.equals(null)必须返回false。
3. hashCode() 方法：equals() 的“好搭档”
你可能会好奇，为啥讲完 equals() 突然蹦出个 hashCode()？它们俩可是紧密相连的“好搭档”！
hashCode() 方法返回一个对象的散列码（哈希值），通常是一个整数。它的主要作用是在基于散列的集合（如 HashSet、HashMap、Hashtable）中提高对象的存储和查找效率。
Java 对 equals() 和 hashCode() 有一个非常重要的约定：
如果两个对象通过
equals()方法比较为相等，那么它们的hashCode()方法必须返回相同的值。
反之则不然：如果两个对象的 hashCode() 值相同，它们不一定 equals() 相等（这被称为“哈希冲突”）。
不重写 hashCode() 的后果：
假设你只重写了 equals() 方法，却没有重写 hashCode()。当你在 HashSet 中添加对象时，就会出问题：
// 沿用只重写了 equals() 的 StudentWithEquals 类
StudentWithEquals sE = new StudentWithEquals("王五", "2023003");
StudentWithEquals sF = new StudentWithEquals("王五", "2023003");
System.out.println("sE.equals(sF): " + (sE.equals(sF))); // true
Set<StudentWithEquals> studentSet = new HashSet<>();
studentSet.add(sE);
System.out.println("集合是否包含 sF？" + studentSet.contains(sF)); // 糟糕！可能是 false！
为什么会这样？因为 HashSet 在判断是否包含某个对象时，会先比较其 hashCode()。如果你没重写 hashCode()，那么 sE 和 sF 尽管内容相等，但它们的默认 hashCode()（基于内存地址）却不同。HashSet 就会认为它们是不同的对象，导致查找失败。
正确做法：同时重写 equals() 和 hashCode()
import java.util.Objects; // Java 7+ 提供了 Objects.hash() 方法，方便生成哈希码
class StudentComplete {
String name;
String studentId;
public StudentComplete(String name, String studentId) {
this.name = name;
this.studentId = studentId;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
StudentComplete that = (StudentComplete) obj;
return Objects.equals(name, that.name) &&
Objects.equals(studentId, that.studentId);
}
@Override
public int hashCode() {
return Objects.hash(name, studentId); // 使用 Objects.hash() 简洁高效
}
}
StudentComplete sG = new StudentComplete("赵六", "2023004");
StudentComplete sH = new StudentComplete("赵六", "2023004");
System.out.println("sG.equals(sH): " + (sG.equals(sH))); // true
Set<StudentComplete> completeSet = new HashSet<>();
completeSet.add(sG);
System.out.println("集合是否包含 sH？" + completeSet.contains(sH)); // true (完美！)
小贴士：现代 IDE（如 IntelliJ IDEA、Eclipse）都提供了强大的功能，可以自动生成 equals() 和 hashCode() 方法。这大大简化了开发，同时也能确保生成的代码符合规范。建议你多加利用！
4. 总结：何时用 ==，何时用 equals()？
通过上面的深度解析，相信你对 == 和 equals() 的区别与联系已经有了清晰的认识。
记住以下核心准则：
-
当你需要比较两个基本数据类型的值时，使用
==。 -
当你需要判断两个引用类型变量是否指向内存中的同一个对象时，使用
==。 -
当你需要判断两个对象的内容是否逻辑上相等**时，使用
equals()方法。但前提是，这个类的equals()方法必须已经被正确重写过（或者你就是想用其默认的内存地址比较）。 -
重写
equals()方法时，请务必同时重写hashCode()方法，以确保在散列集合中（如HashSet,HashMap）的正确性和性能。
理解并正确使用 == 和 equals() 是每个 Java 开发者必备的基本功。掌握了它们，你就能更自信地处理对象比较，写出更健壮、更高效的 Java 代码！
你还在 Java 对象比较上遇到过哪些“坑”呢？欢迎在评论区分享你的经验或提问！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
