重写了equals方法后不一定要重写hashcode()

本文详细解释了Java中equals方法和hashCode方法的作用及其实现原理。介绍了equals方法用于判断两个对象是否相等,而hashCode方法则返回对象的哈希码值,主要用于哈希表的查找。此外还探讨了在什么情况下需要重写hashCode方法。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

equals方法是用来干嘛的?

以下是官方说法(来自 JDK API1.7)

<span style="font-size:18px;">Indicates whether some other object is "equal to" this one. </span>
翻译:显示一些其他对象是否“等于”这一个。

hashcode方法是用来干嘛的?

以下是官方说法(来自 JDK API1.7)

<span style="font-size:18px;">Returns a hash code value for the object. This method is supported for the benefit of hash tables such as those provided by java.util.HashMap. </span>
翻译:返回这个对象的hash code值这种方法支持哈希表的好处比如由java.util.HashMap提供(就是便于查找的意思)。

看equals源码

1.在没有重写equals的时候,我们调用对象的equals方法时,都是用的Object类的,

是直接比较内存地址是否一致。没有用到hashcode。源码如下:

<span style="font-size:18px;"><span style="font-size:18px;">public boolean equals(Object obj) {
        return (this == obj);
    }</span></span>


2.重写了equals的方法,以Integer的equals为例,

是直接比较对象内的值是否相等。没有用到hashcode。源码如下:

<span style="font-size:18px;">  public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }</span>

参考源码可得,equals方法跟HashCode方法没有直接关系。

什么时候需要重写hashcode?

AbstractSet类的hashcode方法实现的注释有这么一段

...This ensures that s1.equals(s2) implies that s1.hashCode()==s2.hashCode() for any two sets s1 and s2...

也就是说,AbstractSet这个类的equals方法相等时要求hashcode也相等的。

所以,你只要用了AbstractSet的子类,如HashSet,EntrySet等 

它们判断是否为同一个对象的条件是equals()为true,并且hashcode相等。

以下是从网上弄来的一个例子:

只有同时重写hashcode和equals方法时,Set的里面才只有一个对象。

public class HashTest {
	private int i;

	public int getI() {
		return i;
	}

	public void setI(int i) {
		this.i = i;
	}

	public int hashCode() {
		return i % 10;
	}
	
	public boolean equals(Object object) {  
        if (object == null) {  
            return false;  
        }  
        if (object == this) {  
            return true;  
        }  
        if (!(object instanceof HashTest)) {  
            return false;  
        }  
        HashTest other = (HashTest) object;  
        if (other.getI() == this.getI()) {  
            return true;  
        }  
        return false;  
    }
	public final static void main(String[] args) {
		HashTest a = new HashTest();
		HashTest b = new HashTest();
		a.setI(1);
		b.setI(1);
		Set<HashTest> set = new HashSet<HashTest>();
		set.add(a);
		set.add(b);
		System.out.println(a.hashCode() == b.hashCode());
		System.out.println(a.equals(b));
		System.out.println(set);
	}
}

<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省略@Overridepublicbooleanequals(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@OverridepublicinthashCode(){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. **单元测试**:验证契约是否满足
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值