Java中==对基本类型比较值，对对象比较引用地址；对象内容比较应使用equals()，且重写equals()时必须重写hashCode()以保证哈希集合的正确性。
在Java里，
==
这个操作符，说白了，它就是用来比较两个东西是不是“同一个”。对于基本数据类型（比如
int
,
boolean
,
double
），它比较的是它们的值是否相等。但对于对象（比如
String
、你自定义的类），它比较的则是这两个引用变量是否指向内存中的同一个对象实例。这听起来简单，却是很多Java初学者甚至一些老手都会偶尔“翻车”的地方，因为我们常常想当然地认为它应该比较“内容”是否一样。
解决方案
要搞清楚Java里
==
的用法，得把基本类型和对象类型分开看，这两种情况下的行为逻辑完全不同。
1. 基本数据类型（Primitive Types）的比较： 当涉及到
int
、
long
、
float
、
double
、
char
、
byte
、
short
、
boolean
这些基本数据类型时，
==
的行为非常直观：它直接比较这两个变量存储的实际数值是否相等。
int a = 10; int b = 10; System.out.println(a == b); // 输出 true char c1 = 'A'; char c2 = 'A'; System.out.println(c1 == c2); // 输出 true boolean flag1 = true; boolean flag2 = false; System.out.println(flag1 == flag2); // 输出 false
这没什么好说的，符合直觉。
2. 对象（Object Types）的比较： 这才是
==
真正让人“头疼”的地方。对于所有非基本数据类型的对象（包括
String
、数组、自定义类的实例，以及包装类如
Integer
、
double
等），
==
比较的不是它们的内容，而是它们在内存中的地址。也就是说，它检查的是这两个引用变量是否指向了内存中的同一个对象。
String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1 == s2); // 输出 false String s3 = "world"; // 字符串字面量，会进入常量池 String s4 = "world"; // s4会引用常量池中与s3相同的对象 System.out.println(s3 == s4); // 输出 true Object obj1 = new Object(); Object obj2 = new Object(); System.out.println(obj1 == obj2); // 输出 false // 即使内容相同，只要是两个不同的对象，== 就返回false
你可能会疑惑，
s3 == s4
为什么是
true
？这是因为Java对字符串字面量做了优化，它们会被存储在字符串常量池中，如果内容相同，会复用同一个对象。但通过
new String()
方式创建的字符串，每次都会在堆内存中创建一个新的对象。
立即学习“Java免费学习笔记（深入）”；
所以，如果你想比较两个对象的内容是否相等，几乎总是应该使用它们的
equals()
方法，而不是
==
。
Java中
==
==
对对象比较的陷阱与原理是什么？
说实话，
==
对于对象来说，它的本意就是判断“身份”是否一致，而不是“内容”是否一致。这其实是个非常底层且高效的判断，因为它只需要比较两个内存地址。但对于我们日常编程，尤其是在处理像
String
这样的“值类型”对象时，往往希望比较的是内容，这就造成了认知上的偏差，进而产生了“陷阱”。
最典型的例子就是字符串。一个初学者写下
if (myString == "某个值")
，往往会得到意想不到的结果。因为
myString
可能是在运行时动态生成的，即使它的字符序列和
"某个值"
一模一样，它们在内存中也可能是两个不同的
String
对象。
String user_input = new Scanner(System.in).nextLine(); // 假设用户输入 "admin" String expected_value = "admin"; // 这是一个常见的错误示范！ if (user_input == expected_value) { System.out.println("匹配成功 (可能是巧合或者字符串常量池的魔术)"); } else { System.out.println("匹配失败 (更常见的结果)"); } // 正确的做法 if (user_input.equals(expected_value)) { System.out.println("匹配成功 (内容相等)"); }
这种设计并非Java的“缺陷”，而是其对引用类型和值类型的区分。
==
提供了最基本的引用比较能力，而
equals()
则提供了更高级、可自定义的“值”比较能力。理解这一点，就能避开很多坑。
Java中包装类（Wrapper Classes）的
==
==
比较有何特殊之处？
包装类，比如
Integer
、
long
、
boolean
等，它们是基本数据类型的对象表示。当用
==
比较两个包装类对象时，遵循的是对象比较的规则，即比较引用地址。然而，这里又有一个小小的“陷阱”——缓存机制和自动装箱/拆箱。
Java为了性能优化，对一些常用的包装类值进行了缓存。例如，
Integer
类在
-128
到
127
之间的值会被缓存。这意味着，如果你创建两个
Integer
对象，它们的值在这个范围内且是通过自动装箱创建的，那么它们很可能引用的是同一个缓存对象。
Integer i1 = 100; // 自动装箱，从缓存获取 Integer i2 = 100; // 自动装箱，从缓存获取 System.out.println(i1 == i2); // 输出 true (因为100在缓存范围内，引用的是同一个对象) Integer i3 = 200; // 自动装箱，不在缓存范围内，创建新对象 Integer i4 = 200; // 自动装箱，不在缓存范围内，创建新对象 System.out.println(i3 == i4); // 输出 false (两个不同的对象) // 显式创建新对象，即使值在缓存范围内，也会创建新对象 Integer i5 = new Integer(100); Integer i6 = new Integer(100); System.out.println(i5 == i6); // 输出 false
这真的是一个非常隐蔽的坑。我个人就见过不少代码因为不了解这个缓存机制，在比较
Integer
时误用
==
导致偶发性 bug 的。所以，永远建议使用
equals()
方法来比较包装类对象的值，这样可以避免这些由缓存和对象创建方式带来的不确定性。
Integer val1 = 200; Integer val2 = 200; System.out.println(val1.equals(val2)); // 输出 true，这是正确的比较方式
何时应该使用
equals()
equals()
方法，以及如何正确重写它？
当你需要比较两个对象的“内容”或“语义”是否相等时，就应该使用
equals()
方法。这是Java中所有对象都继承自
Object
类的一个方法，它的默认实现和
==
一样，也是比较引用地址。因此，对于自定义的类，如果你希望它们在内容相同时被认为是相等的，你就必须重写
equals()
方法。
何时使用
equals()
：
- 比较两个
String
对象的内容。
- 比较两个自定义对象（例如
Person
类，你希望姓名和年龄都相同的两个人被认为是相等的）。
- 比较包装类对象的值。
- 比较集合框架中的元素（例如
ArrayList
、
HashSet
中的元素）。
如何正确重写
equals()
： 重写
equals()
方法时，必须遵循
Object
类中定义的一系列“约定”（contract），否则可能会导致不可预测的行为，尤其是在使用集合类时。这些约定包括：
- 自反性 (Reflexive)： 对于任何非
null
的引用值
x
，
x.equals(x)
必须返回
true
。
- 对称性 (Symmetric)： 对于任何非
null
的引用值
x
和
y
，当且仅当
y.equals(x)
返回
true
时，
x.equals(y)
才返回
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)
都会返回相同的结果。
- 非空性 (Nullity)： 对于任何非
null
的引用值
x
，
x.equals(null)
必须返回
false
。
此外，一个非常重要的最佳实践是：如果重写了
equals()
方法，就必须同时重写
hashCode()
方法。 这是因为
HashSet
、
HashMap
等基于哈希表的集合类在存储和查找对象时，会先使用
hashCode()
来确定对象的存储位置，再使用
equals()
来确认对象是否相等。如果
equals()
相等的两个对象
hashCode()
不相等，就会导致在哈希集合中找不到本应存在的对象。
一个简单的
Person
类重写
equals()
和
hashCode()
的例子：
import java.util.Objects; // Java 7+ 引入的 Objects.equals 和 Objects.hash 简化了代码 class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } @Override public boolean equals(Object o) { // 1. 检查是否是同一个对象引用，这是最快的判断 if (this == o) return true; // 2. 检查传入对象是否为null，以及类型是否匹配 // getClass() 比 instanceof 更严格，要求类型完全一致 if (o == null || getClass() != o.getClass()) return false; // 3. 类型转换 Person person = (Person) o; // 4. 比较关键字段 // 基本类型直接比较值 // 引用类型使用其 equals 方法比较 return age == person.age && Objects.equals(name, person.name); } @Override public int hashCode() { // 使用 Objects.hash() 可以方便地为多个字段生成哈希码 return Objects.hash(name, age); } @Override public String toString() { return "Person{" + "name='" + name + ''' + ", age=" + age + '}'; } } // 使用示例 // Person p1 = new Person("张三", 30); // Person p2 = new Person("张三", 30); // System.out.println(p1.equals(p2)); // 输出 true // System.out.println(p1 == p2); // 输出 false
正确重写
equals()
和
hashCode()
是构建健壮Java应用的关键一步，尤其是在处理数据模型和集合时。如果忽略了这些细节，后期排查问题可能会非常痛苦。
评论（已关闭）
评论已关闭