.equals和==的区别以及为什么重写.equals必须重写hashcode-优快云博客

本文链接：https://blog.youkuaiyun.com/2303_78263863/article/details/146212162

1. 核心区别（总述）

**==：比较的是内存地址（对引用类型）或基本类型的值**。
**.equals()：比较的是对象内容的逻辑相等性**（需重写方法，默认行为与==相同）。

2. 分点详解

（1）==的使用场景

基本数据类型：直接比较值是否相等（如int a = 5; int b = 5; a == b → true）。

引用类型：比较两个引用是否指向同一内存对象。

java

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2); // false（不同对象）

（2）.equals()的使用场景

默认行为：继承自Object类，等价于==（比较内存地址）。

重写规则：需在类中重写equals()方法以定义逻辑相等性。

java

// String类重写equals()，比较字符内容
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1.equals(s2)); // true

（3）关键注意事项

必须同时重写hashCode()：若对象用于哈希表（如HashMap），需保证相等对象有相同哈希码。
空指针安全：调用a.equals(b)时，若a可能为null，应使用Objects.equals(a, b)。

字符串常量池优化：

java

String s1 = "java";  // 常量池
String s2 = "java";
System.out.println(s1 == s2); // true（共享同一常量对象）

3. 示例对比（结合代码）

java

Person p1 = new Person("Alice"); // 假设Person类未重写equals()
Person p2 = new Person("Alice");

System.out.println(p1 == p2);       // false（不同对象）
System.out.println(p1.equals(p2)); // false（未重写equals()，默认用==比较）

// 若Person重写equals()比较name字段：
@Override
public boolean equals(Object o) {
    return o != null && o instanceof Person && ((Person) o).name.equals(this.name);
}
System.out.println(p1.equals(p2)); // true（name相同）

4. 总结（强调核心）

**==**：用于基本类型值比较或引用地址一致性检查。
**.equals()**：用于对象内容逻辑相等性判断（需主动重写）。
最佳实践：始终重写equals()和hashCode()，使用Objects.equals()避免空指针。

加分回答技巧

结合项目经验：
“在之前的项目中，我们遇到过因未重写equals()导致HashSet重复存储的问题，后来通过重写这两个方法解决了Bug。”
延伸原理：
“比如HashMap的get(key)会先通过hashCode()定位桶，再用equals()确认键是否匹配，因此两者必须逻辑一致。”
陷阱提示：
“注意BigDecimal等不可变类重写了equals()，但compareTo()和equals()的结果可能不一致（如2.0和2.00）。”

在Java中，.equals()和==用于比较操作，但它们的用途和底层逻辑有本质区别：

1. `==` 运算符

作用：比较两个变量的值是否相等。
适用范围：
- 基本数据类型（如int、char等）：直接比较数值。
  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. `.equals()` 方法

作用：比较两个对象的内容是否逻辑相等。
默认行为：继承自Object类，等效于==（即比较内存地址）。

重写规则：需在类中重写equals()方法以定义内容相等的逻辑。

java

// String类重写的equals()方法
public boolean equals(Object obj) {
    if (this == obj) return true; // 同一对象直接返回true
    if (obj instanceof String) {
        String other = (String) obj;
        return 逐个比较字符是否相同;
    }
    return false;
}

示例：

java

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1.equals(s2)); // true（内容相同）

3. 核心区别对比

比较维度	`==`	`.equals()`
比较内容	内存地址或基本数据类型的值	对象内容（需重写方法）
适用类型	基本类型、引用类型	仅引用类型（对象）
行为可定制	不可	可重写方法自定义逻辑
示例结果	`new String("a") == new String("a")` → false	`new String("a").equals(new String("a"))` → true

4. 常见使用场景

场景1：字符串比较

java

String s1 = "java";      // 字符串常量池
String s2 = new String("java"); // 堆内存新对象
System.out.println(s1 == s2);          // false（地址不同）
System.out.println(s1.equals(s2));     // true（内容相同）

场景2：自定义对象比较

java

class Person {
    String name;
    public Person(String name) { this.name = name; }
    
    // 重写equals()方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name);
    }
}

Person p1 = new Person("Alice");
Person p2 = new Person("Alice");
System.out.println(p1 == p2);       // false（不同对象）
System.out.println(p1.equals(p2));  // true（name相同）

5. 注意事项

空指针问题：调用.equals()时需确保对象非null。

java

String s1 = null;
String s2 = "hello";
// System.out.println(s1.equals(s2)); // 抛出NullPointerException
System.out.println(Objects.equals(s1, s2)); // 安全写法（返回false）

重写一致性：若重写equals()，必须同时重写hashCode()（如用于HashMap的键）。
不可变对象：如String、Integer等已重写equals()，可直接使用。

总结

**==**：用于基本类型值比较或引用类型地址比较。
**.equals()**：用于对象内容比较（需重写方法）。
优先使用Objects.equals(a, b)工具方法避免空指针异常。

在Java中，重写equals()方法时必须同时重写hashCode()方法，这是为了遵守Java对象的契约约定（Contract），确保对象在哈希表（如HashMap、HashSet）等依赖哈希码的数据结构中能正确工作。以下是具体原因和实现规范：

1. Java对象契约的强制要求

根据Java官方规范：

规则1：如果两个对象通过equals()方法比较结果为true，它们的hashCode()返回值必须相同。
规则2：如果两个对象hashCode()不同，它们的equals()结果必须为false。

违反后果：

当对象作为HashMap的键时，可能无法正确检索到已存在的值。
HashSet可能存储重复对象，破坏集合的唯一性。

2. 场景示例：HashMap的键冲突

假设有一个类Person，仅重写equals()但未重写hashCode()：

java

class Person {
    String id;
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(id, person.id); // 仅通过id判断相等
    }
    // 未重写hashCode()，默认使用Object.hashCode()
}

// 测试代码
Person p1 = new Person("A123");
Person p2 = new Person("A123"); // id相同，equals()返回true

Map<Person, String> map = new HashMap<>();
map.put(p1, "张三");
map.get(p2); // 返回null！因为p1和p2的hashCode不同

结果：p1和p2逻辑相等，但因哈希码不同，无法在HashMap中正确关联到同一个值。

3. 实现规范

如何正确重写`hashCode()`

方法1：使用Objects.hash()工具类（推荐）

java

@Override
public int hashCode() {
    return Objects.hash(id); // 生成基于id的哈希码
}

方法2：手动组合哈希码（兼容旧版本Java）
java
```
@Override
public int hashCode() {
    int result = 17;
    result = 31 * result + (id == null ? 0 : id.hashCode());
    return result;
}
```
参数选择：31是奇素数，可减少哈希冲突，且JVM优化乘法为位运算。

验证一致性

java

Person p1 = new Person("A123");
Person p2 = new Person("A123");

System.out.println(p1.equals(p2)); // true
System.out.println(p1.hashCode() == p2.hashCode()); // true

4. 哈希表的工作原理

以HashMap为例：

存储时：
- 通过hashCode()计算桶（Bucket）的位置。
- 若桶中已有元素，再通过equals()比较键是否相等。
查询时：
- 先通过hashCode()定位桶，再用equals()确认键是否匹配。

未正确实现的影响：

即使equals()返回true，hashCode()不同会导致对象被分配到不同桶，永远无法触发equals()比较。

5. 特例与注意事项

仅用equals()的场景：如果对象不用于任何哈希结构（如仅用于ArrayList），理论上可不重写hashCode()。但强烈建议遵守规范，避免未来扩展隐患。
性能优化：hashCode()应尽量均匀分布，减少哈希冲突（如String的哈希码经过精心设计）。
不可变对象：若对象作为哈希结构的键且字段可变，需确保哈希码在生命周期内稳定，或避免修改关键字段。

总结

操作	目的	必要性
重写`equals()`	定义对象逻辑相等的规则	必须
重写`hashCode()`	保证相等对象具有相同哈希码	强制要求（若使用哈希结构）

核心原则：
相等的对象必须产生相同的哈希码，但哈希码相同的对象不一定相等。
遵循这一规则，才能确保Java集合框架的正确性和程序的健壮性