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()方法。这是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应用的关键一步，尤其是在处理数据模型和集合时。如果忽略了这些细节，后期排查问题可能会非常痛苦。
