<think>在
Java中，当我们
重写`
equals`
方法时，通常也需要
重写`
hashCode`
方法。这是因为`
hashCode`和`
equals`
方法之间有一个必须遵守的契约（contract），这个契约定义在`Object`类的规范中，并且对于使用基于散列的集合（如`HashMap`、`HashSet`、`Hashtable`等）的正确行为至关重要。###
为什么必须同时
重写？1.**契约要求**：-如果两个对象通过`
equals`
方法比较是相等的，那么这两个对象调用`
hashCode`
方法必须返回相同的整数结果。-如果两个对象通过`
equals`
方法比较是不相等的，它们`
hashCode`
方法的返回值可以相同，但是为不相等的对象生成不同的哈希值有助于提高散列表的性能。2.**违反契约的后果**：-当我们将对象放入基于散列的集合（如`HashMap`）时，集合会使用对象的`
hashCode`值来确定存储位置（桶）。-如果两个对象相等（根据`
equals`
方法），但它们的`
hashCode`不同，那么它们可能会被放入不同的桶中。这样，当你尝试使用其中一个对象作为键去检索时，可能无法找到另一个相等的对象，导致集合行为异常。###示例说明：假设我们有一个类`Person`，我们只
重写了`
equals`
方法而没有
重写`
hashCode`
方法：```
javapublicclassPerson{privateStringname;privateintage;//构造
方法、getter、setter省略@Overridepublicboolean
equals(Objectobj){if(this==obj)returntrue;if(obj==null||getClass()!=obj.getClass())returnfalse;Personperson=(Person)obj;returnage==person.age&&Objects.
equals(name,person.name);}//没有
重写hashCode}```现在，如果我们创建两个相等的`Person`对象并放入`HashSet`：```
javaPersonp1=newPerson("Alice",30);Personp2=newPerson("Alice",30);System.out.println(p1.
equals(p2));//输出trueSet<Person>set=newHashSet<>();set.add(p1);set.add(p2);System.out.println(set.size());//输出2？我们希望是1，因为它们是相等的```由于没有
重写`
hashCode`，`p1`和`p2`可能产生不同的哈希码（默认使用`Object`的`
hashCode`
方法，通常根据内存地址生成），因此`HashSet`认为它们是两个不同的对象，从而都存入集合中，这违反了集合的唯一性要求。###正确做法：
重写`
hashCode`
方法，确保相等的对象具有相同的哈希码。通常我们可以使用`Objects.hash`
方法来生成：```
java@Overridepublicint
hashCode(){returnObjects.hash(name,age);}```这样，`p1`和`p2`的哈希码就相同了，`HashSet`会正确地将它们视为同一个对象。###总结原因：1.**契约要求**：`Object`类中定义的契约必须遵守，否则会导致使用散列集合时出现不可预测的行为。2.**一致性**：当两个对象相等时，它们必须有相同的哈希码，这样在散列集合中才能被正确识别为同一个对象。3.**性能**：虽然不相等的对象可以拥有相同的哈希码（哈希冲突），但良好的`
hashCode`实现可以减少冲突，提高散列表的性能。###注意事项：-
重写`
hashCode`时，应确保参与计算哈希码的字段与`
equals`
方法中使用的字段一致。-哈希码计算应尽量均匀分布，以减少冲突。§§相关问题§§:1.在
Java中，`
equals`
方法和`==`运算符有什么区别？2.如何正确实现一个类的`
equals`
方法？3.在
重写`
hashCode`
方法时，
为什么要求相等的对象必须返回相同的哈希码？4.什么是哈希冲突？在
Java中如何处理哈希冲突？</think>###
为什么重写equals方法一定要
重写hashCode？
在
Java中，
重写`
equals()`
方法后必须同时
重写`
hashCode()`
方法，这是由
Java对象契约（Object Contract）强制要求的。这个要求主要基于以下关键原因：
#### 1. **哈希集合的依赖关系**
Java的哈希集合（如`HashMap`、`HashSet`、`Hashtable`）依赖`
hashCode()`和`
equals()`协同工作：
- `
hashCode()`：确定对象在哈希桶中的位置（快速定位）
- `
equals()`：精确比较桶中的对象是否相等
```
java
import
java.util.HashMap;
import
java.util.Objects;
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//
重写equals但未
重写hashCode（错误示例）
@Override
public boolean
equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.
equals(name, person.name);
}
}
public class
HashCodeExample {
public static void main(String[] args) {
Person p1 = new Person("Alice", 30);
Person p2 = new Person("Alice", 30);
System.out.println(p1.
equals(p2)); // true（逻辑相等）
HashMap<Person, String> map = new HashMap<>();
map.put(p1, "Employee");
// 违反契约导致错误结果
System.out.println(map.get(p2)); // 输出null！应该返回"Employee"
}
}
```
#### 2. **Object类契约要求**
Java API规范明确规定：
- **一致性**：当`a.
equals(b)`返回`true`时，`a.
hashCode()`必须等于`b.
hashCode()`
- **逆否命题**：如果`
hashCode()`不同，`
equals()`必须返回`false`
- **稳定性**：同一对象多次调用`
hashCode()`应返回相同值（前提对象未修改）
#### 3. **违反契约的后果**
1. **哈希集合行为异常**：
- 逻辑相等的对象被存入不同哈希桶
- `contains()`、`get()`等
方法返回错误结果
2. **破坏集合唯一性**：
- `HashSet`可能包含多个"相等"对象
3. **内存泄漏风险**：
- 无法正确检索已存入哈希表的对象
4. **违反
Java规范**：
- 可能导致难以追踪的bug
#### 正确实现方式
```
java
class CorrectPerson {
private String name;
private int age;
// 构造
方法等省略...
@Override
public boolean
equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
CorrectPerson that = (CorrectPerson) o;
return age == that.age && Objects.
equals(name, that.name);
}
@Override
public int
hashCode() {
// 使用相同字段计算哈希码
return Objects.hash(name, age);
}
}
```
### 关键原理总结
| 原则 | 要求 | 违反后果 |
|------|------|----------|
| **相等对象哈希码相同** | `a.
equals(b) ⇒ a.
hashCode() == b.
hashCode()` | 哈希集合无法正确查找 |
| **哈希码一致性** | 对象未修改时多次调用结果相同 | 集合存储位置错误 |
| **非相等对象哈希码可同** | `!a.
equals(b)`时哈希码可相同 | 仅影响性能（哈希冲突） |
### 最佳实践
1. **同时
重写**：总是成对
重写`
equals()`和`
hashCode()`
2. **使用相同字段**：两个
方法应基于相同的对象属性
3. **利用工具类**：使用`Objects.hash()`或`Objects.
equals()`简化实现
4. **不可变字段**：优先选择不可变字段参与计算
5. **单元测试**：验证契约是否满足
本文详细解析了在使用自定义对象作为HashMap键时，重写hashCode()和equals()方法的重要性。阐述了如果不正确地重写这两个方法，将如何影响HashMap内部的键值匹配过程。
扫一扫
1635
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
