只重写equals()但不重写hashCode会有什么后果?

博客介绍了equals和hashCode的关系,即equals相等的两个对象hashCode一定相等,但hashCode相等的两个对象equals不一定相等。还阐述了重写equals方法时,若不重写hashCode在散列表相关集合类中的影响,强调类用于Hash相关集合类时,重写equals需重写hashCode。

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

转载自https://www.cnblogs.com/guanmu/p/4894430.html


首先,说下equals和hashCode的关系。JDK API中关于Object类的equals和hashCode方法中说过,总结起来就是两句话:equals相等的两个对象的hashCode也一定相等,但hashCode相等的两个对象不一定equals相等。

 

 hashCode类似于一个位置值(不叫地址值,是想把每个对象所在的位置做地址值),HashSet、HashMap等集合类中常会用到。

上图中假设是对象在内存中的模型,则7~c就是位置值,即hashCode。而71—74就是对象地址值。所以x,y和z的hashCode是一样的,但是x、y和z的equals不一定相等equals相等 只跟自己类定义的equals方法有关。

假设x是A类的对象,y是B类对象,z是C类对象,A、B和C的equals()都实现为始终返回true,则程序会认为x、y和z是相等的;若都实现为返回false,则x跟自己都不相等。

即equals()是否相等,只依据自定义的equals()方法的判断结果。

  当我们重写equals方法时,是有要求的(具体见JDK)。如果只重写了equals,不重写hashCode会有什么影响呢?

  假如该类不会放在HashSet等散列表相关的集合类中,不一定会有影响,如下代码:

Model类:

package com.guanmu.test;


/**
 * <p>
 * 类描述:
 * <p>
 * 
 * 所属插件:com.guanmu.test
 * 
 * @author guanmu 2015-10-20
 * 
 */
public class Model {

    private String name;
    private String age;
    private String otherName;

    /**
     * @param name
     * @param age
     * @param otherName
     */
    public Model(String name, String age, String otherName) {
        super();
        this.name = name;
        this.age = age;
        this.otherName = otherName;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name
     *            the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the age
     */
    public String getAge() {
        return age;
    }

    /**
     * @param age
     *            the age to set
     */
    public void setAge(String age) {
        this.age = age;
    }

    /**
     * @return the otherName
     */
    public String getOtherName() {
        return otherName;
    }

    /**
     * @param otherName
     *            the otherName to set
     */
    public void setOtherName(String otherName) {
        this.otherName = otherName;
    }

    @Override
    public int hashCode() {
        
        int a = 7;
        int b = 11;
        // a和b为不相等的int型常量
        int r = a;
        r = r*b + name.hashCode();
        r = r*b + age.hashCode();
        
//        return r;
        return super.hashCode();
    }
    
    /* 注意这个重写的equals()只用了name与age这两个属性!!! */
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Model)) {
            return false;
        }

        Model other = (Model) obj;
        if (name.equals(other.getName()) && age.equals(other.getAge())) {
            return true;
        }

        return false;
    }

    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "Model [name=" + name + ", age=" + age + ", otherName=" + otherName + "]";
    }
    
    
}

测试类:

package com.guanmu.test;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * <p>
 * 类描述:
 * <p>
 * 
 * 所属插件:com.guanmu.test
 * @author guanmu2015-10-20
 * 
 */
public class EqualsTest {
    

    
    public static void main(String[] args) {
        test1();
        test2();
    }
    
    public static void test1() {
        System.out.println("####:test1");
        List<Model> list = new ArrayList<Model>();
        
        Model a = new Model("a", "20", "test");
        Model b = new Model("a","20","abcdef");
        Model c = new Model("a","20","");
        
        list.add(a);
        System.out.println("a-hashCode:" + a.hashCode());
        System.out.println(list);
        if (!list.contains(b)) {
            list.add(b);
            System.out.println("b-hc:" + b.hashCode());
            System.out.println(list);
        }
        
    }
    
    public static void test2() {
        System.out.println("####:test2");
        Set<Model> set = new HashSet<Model>();
        
        Model a = new Model("a", "20", "test");
        Model b = new Model("a","20","abcdef");
        Model c = new Model("a","20","");
        
        set.add(a);
        System.out.println("a-hashCode:" + a.hashCode());
        System.out.println(set);
        if (!set.contains(b)) {
            set.add(b);
            System.out.println("b-hc:" + b.hashCode());
            System.out.println(set);
        }
        
    }
}

结果打印如下:

####:test1
a-hashCode:18923308
[Model [name=a, age=20, otherName=test]]
####:test2
a-hashCode:15136722
[Model [name=a, age=20, otherName=test]]
b-hc:26752749
[Model [name=a, age=20, otherName=test], Model [name=a, age=20, otherName=abcdef]]

  1. list中能判断出包含了等价的b(因为a和b的name和age属性相同,所以我们自定义的equals()方法就认为a与b等价)
  2. 但set中认为a和b不相等,set中没有包含b。
  • 发现test1()中,ArrayList只根据equals()来判断两个对象是否相等,而不管hashCode是否不相等。
  • 而test2()中,HashSet判断流程则不一样,①先判断两个对象的hashCode方法是否一样;②如果不一样,立即认为两个对象equals不相等,并不调用equals方法;③当hashCode相等时,再根据equals方法判断两个对象是否相等。

  总结,所以当我们所写的类可能用于存放在Hash相关的集合类中时,在重写equals时,需要重写hashCode,不然会出现与预期不符的结果。从网上搜索了下如何重写hashCode方法,以下据说是《Think in Java》中提到的方法。

@Override
    public int hashCode() {
        
        int a = 7;
        int b = 11;
        // a和b为不相等的int型常量
        int r = a;
        r = r*b + name.hashCode();
        r = r*b + age.hashCode();
        
        return r;
    }

其中a和b可以为任意不相等常量。

 

<think>嗯,用户问的是如果只重写equals方法而重写hashcode会有什么影响。这个问题看起来和之前关于hashCode范围的问题有关联,所以可能需要回顾一下之前的讨论。用户可能是在学习Java的equalshashCode方法,或者遇到了相关的bug,想知道重写hashCode后果。 首先,Java中的equalshashCode是有契约的,根据Object类的规范,如果两个对象equals返回true,它们的hashCode必须相同。如果用户只重写equals重写hashCode,那么当两个对象根据equals方法相等时,它们的hashCode可能同,这违反了契约。 接下来,需要具体说明违反契约带来的问题。例如,在使用散列集合(如HashMap、HashSet)时,对象可能无法正确被找到,导致行为异常。比如,把两个equals相等的对象放入HashSet,它们会被视为同的元素,因为hashCode同,所以可能存储在同的桶里,导致重复元素的存在。 还要提到潜在的bug,比如当对象作为键时,无法正确检索到对应的值。比如,用对象作为HashMap的键,修改对象的状态后,由于hashCode变化,可能导致无法找到之前存入的值。 另外,需要解释为什么默认的hashCode实现(基于内存地址)在重写equals后可能适用。因为如果equals是根据对象内容判断的,而hashCode还是基于地址,那么内容相同的两个对象可能有同的hashCode,导致问题。 可能还需要举例说明,比如一个简单的Person类,重写equals比较ID,但重写hashCode。当两个Person对象ID相同但hashCode同时,放入HashSet会出现重复。 最后,要总结正确的做法,即重写equals时必须同时重写hashCode,并确保它们遵循相同的属性。同时,可以提到IDE如Eclipse或IntelliJ可以自动生成这两个方法,避免手动错误。</think>--- ### **仅重写 `equals` 但重写 `hashCode` 的影响** 在 Java 中,`equals()` 和 `hashCode()` 方法之间存在 **强制契约**。若只重写 `equals()` 而忽略 `hashCode()`,会直接违反该契约,导致以下问题: --- #### **1. 违反 `hashCode` 的约定** 根据 Java 规范: - **若 `obj1.equals(obj2) == true`,则 `obj1.hashCode() == obj2.hashCode()` 必须成立。** - **反之,若哈希码同,则对象一定相等**(但哈希码相同保证对象相等)。 **后果**: 若两个对象通过 `equals()` 判定为相等,但它们的哈希码同(因未重写 `hashCode()`,仍使用 `Object` 默认的地址哈希),会直接破坏这一约定。 **示例**: ```java class Person { private String id; @Override public boolean equals(Object o) { if (o instanceof Person) { return this.id.equals(((Person) o).id); } return false; } // 未重写 hashCode() } Person p1 = new Person("123"); Person p2 = new Person("123"); System.out.println(p1.equals(p2)); // true(内容相同) System.out.println(p1.hashCode() == p2.hashCode()); // false(默认哈希基于地址) ``` --- #### **2. 散列集合(如 `HashMap`、`HashSet`)行为异常** **关键问题**: 散列集合依赖 `hashCode()` 确定对象的存储位置(桶)。若哈希码匹配 `equals()` 逻辑,对象可能被错误分类。 **具体表现**: - **重复元素进入 `HashSet`**: 两个 `equals` 相等的对象因哈希码同,会被分配到同桶中,导致 `HashSet` 包含重复元素。 - **`HashMap` 无法正确检索值**: 使用 `equals` 相等的对象作为键时,可能无法找到对应的值(因哈希码同,定位到错误桶)。 **示例**: ```java HashSet<Person> set = new HashSet<>(); set.add(p1); set.add(p2); System.out.println(set.size()); // 输出 2(期望应为 1) ``` --- #### **3. 潜在的性能问题** - **哈希冲突增加**: 若自定义的 `equals` 基于对象内容,但 `hashCode` 仍基于默认实现(内存地址),哈希码分布可能均匀,导致散列集合的 **链表/红黑树退化**,降低查询效率。 --- ### **解决方案** 必须同时重写 `equals()` 和 `hashCode()`,确保: 1. 若 `equals` 返回 `true`,`hashCode` 必须相同。 2. `hashCode` 应尽量均匀分布,减少冲突(例如通过组合字段哈希值)。 **推荐工具**: - 使用 IDE(如 IntelliJ/Eclipse)自动生成 `equals()` 和 `hashCode()`。 - 利用 `Objects.equals()` 和 `Objects.hash()` 简化代码。 --- ### **代码示例** ```java class Person { private String id; @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(id, person.id); } @Override public int hashCode() { return Objects.hash(id); // 基于 id 生成哈希码 } } ``` --- ### **总结** | **行为** | **后果** | |------------------------|--------------------------------------------------------------------------| | 仅重写 `equals()` | 破坏哈希契约,导致散列集合行为异常、潜在性能问题 | | 同时重写 `equals()` 和 `hashCode()` | 确保对象在逻辑相等时哈希码一致,兼容散列集合的正常操作 | **核心原则**:始终将 `equals()` 和 `hashCode()` 视为可分割的配对方法。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值