我们在重写equals方法时为什么也要重写hashCode方法呢？

最新推荐文章于 2023-03-07 21:17:04 发布

Fight Bravely

最新推荐文章于 2023-03-07 21:17:04 发布

阅读量137

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_44417508/article/details/105914426

版权

说明

1、equals方法是Object类中的一个方法，用于判断其他某个对象是否与此对象“相等”。

官方给出的API说明实现相等关系如下：

自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true
一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上equals 比较中所用的信息没有被修改
传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回true，那么 x.equals(z) 应返回 true。
对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。

请注意，通常每当重写此方法时，都必须重写{@code hashCode}方法，以便维护{@code hashCode}方法的常规协定，该协定规定相等的对象必须具有相等的哈希码。

2、都必须重写{@code hashCode}方法，以便维护{@code hashCode}方法的常规协定？常规协议？？？？？

基于对象的内容实现：当我们只重写了equals方法，而保留hashCode的实现不变，那么很可能某两个对象明明是“相等”，而hashCode却不一样。这样，当你用其中的一个作为键保存到hashMap、hashTable或hashSet中，再以“相等的”key找另一个作为键值中的value时，则根本找不到。

3、hashCode也是Object类中的方法，返回对象的哈希码值。为了支持哈希表（例如由{@link java.util.HashMap}提供的哈希表）而支持此方法。

{@code hashCode}的一般约定为：

在Java应用程序执行期间，只要在同一个对象上多次调用它，{@ code hashCode}方法就必须始终返回相同的整数，前提是在该对象的{@code equals}比较中使用的信息没有被修改。从一个应用程序的一次执行到同一应用程序的另一次执行，此整数不必保持一致。
如果根据{@code equals（Object）}方法两个对象相等，则在两个对象中的每个对象上调用{@code hashCode}方法必须产生相同的整数结果。
根据{@link java.lang.Object＃equals（java.lang.Object）}方法，如果两个对象不相等，则不需要在两个对象中的每个对象上调用{@code hashCode}方法，因为得到的肯定是不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同的整数结果可能会提高哈希表的性能。
在实际的情况下，类{@code Object}定义的hashCode方法确实为不同的对象返回不同的整数。(这通常是通过将对象的内部地址转换为整数来实现的，但是Java™编程语言不需要这种实现技术。)。

看了上述说明，可能会看的云里雾里的，话不多说，请看示例代码

1、Object类中的equals方法

 public boolean equals(Object obj) {
        return (this == obj);
    }

可以看到，不重写equals方法时，它的作用和"=="是没有任何区别的(当我们用 == 来比较基本数据类型时，判断的是基本数据类型中的值是否相等，而比较引用数据类型的话则判断他们引用的内存地址是否相等)。因此，Object类给我们定义这个方法时大部分情况就是拿来给我们重写用的。

2、不重写equals方法和hashCode方法

Person类

public class Person extends Object{
    private String name;
    private String sex;
    private String address;
    
    public Person(String name, String sex, String address) {
        this.name = name;
        this.sex = sex;
        this.address = address;
    }

    public Person() {
    }
}

EqualsAndHashCodeDemo测试类

public class EqualsAndHashCodeDemo {
    public static void main(String[] args) {
        HashMap<Person, Object> map = new HashMap<Person, Object>();

        Person person01 = new Person("brave","男","深圳");
        Person person02 = new Person("brave","男","北京");

        System.out.println("person01的hashCode:"+person01.hashCode());
        System.out.println("person02的hashCode:"+person02.hashCode());
        System.out.println(person01.equals(person02));
        System.out.println(person01 == person02);

        map.put(person01,66);
        map.put(person02,66);

        for(Map.Entry<Person,Object> mapPerson : map.entrySet()){
            System.out.println("key的内存地址为:"+mapPerson.getKey()+" 值为:"+mapPerson.getValue());
        }
    }
}

结果为:

person01的hashCode:1163157884
person02的hashCode:1956725890
false
false
key的内存地址为:com.entity.Person@74a14482 值为:66
key的内存地址为:com.entity.Person@4554617c 值为:66

3、重写equals方法但不重写hashCode方法

Person类

public class Person extends Object{
    private String name;
    private String sex;
    private String address;

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Person){
            Person person = (Person)obj;
            return name.equals(person.name);
        }
        return super.equals(obj);
    }

    public Person(String name, String sex, String address) {
        this.name = name;
        this.sex = sex;
        this.address = address;
    }

    public Person() {
    }
}

EqualsAndHashCodeDemo测试类

public class EqualsAndHashCodeDemo {
    public static void main(String[] args) {
        HashMap<Person, Object> map = new HashMap<Person, Object>();

        Person person01 = new Person("brave","男","深圳");
        Person person02 = new Person("brave","男","北京");

        System.out.println("person01的hashCode:"+person01.hashCode());
        System.out.println("person02的hashCode:"+person02.hashCode());
        System.out.println(person01.equals(person02));
        System.out.println(person01 == person02);

        map.put(person01,66);
        map.put(person02,66);

        for(Map.Entry<Person,Object> mapPerson : map.entrySet()){
            System.out.println("key的内存地址为:"+mapPerson.getKey()+" 值为:"+mapPerson.getValue());
        }
    }
}

结果为:

person01的hashCode:1163157884
person02的hashCode:1956725890
true
false
key的内存地址为:com.entity.Person@74a14482 值为:66
key的内存地址为:com.entity.Person@4554617c 值为:66

4、重写equals方法和hashCode方法

Person类

public class Person extends Object{
    private String name;
    private String sex;
    private String address;

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Person){
            Person person = (Person)obj;
            return name.equals(person.name);
        }
        return super.equals(obj);
    }

    @Override
    public int hashCode() {
        return name.hashCode();
    }

    public Person(String name, String sex, String address) {
        this.name = name;
        this.sex = sex;
        this.address = address;
    }

    public Person() {
    }
}

EqualsAndHashCodeDemo测试类

public class EqualsAndHashCodeDemo {
    public static void main(String[] args) {
        HashMap<Person, Object> map = new HashMap<Person, Object>();

        Person person01 = new Person("brave","男","深圳");
        Person person02 = new Person("brave","男","北京");

        System.out.println("person01的hashCode:"+person01.hashCode());
        System.out.println("person02的hashCode:"+person02.hashCode());
        System.out.println(person01.equals(person02));
        System.out.println(person01 == person02);

        map.put(person01,66);
        map.put(person02,66);

        for(Map.Entry<Person,Object> mapPerson : map.entrySet()){
            System.out.println("key的内存地址为:"+mapPerson.getKey()+" 值为:"+mapPerson.getValue());
        }
    }
}

结果为:

person01的hashCode:93998208
person02的hashCode:93998208
true
false
key的内存地址为:com.entity.Person@59a4c80 值为:66

我们知道map是不允许存在相同的key的，由上面的代码可以知道，如果不重写equals和hashCode方法的话会使得你在使用map的时候出现与预期不一样的结果(不重写上面的方法时在HashMap中会出现key相同但却存放了重复的key)，具体equals和hashCode如何重写，里面的逻辑如何实现需要根据现实当中的业务来规定。

总结

按照官方API说明，在对equals方法重写时一定也要对hashCode方法进行重写。
不重写equals方法时，其作用和“==”一样。
在判断对象是否相等时，equals方法比较相等时，则hashCode方法比较一定相等
在判断对象是否相等时，hashCode方法比较相等时，则equals方法比较不一定相等
在判断对象是否相等时，hashCode方法比较不等时，则equals方法比较一定不相等
在重写完equals方法和hashCode方法后，在判断对象是否相同时都会先去比较其hashCode值是否相等，再使用equals方法进行比较。这样可以减少equals方法的比较次数，提高效率。

Fight Bravely

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
我们在重写equals方法时为什么也要重写hashCode方法呢？

说明1、equals方法是Object类中的一个方法，用于判断其他某个对象是否与此对象“相等”。官方给出的API说明实现相等关系如下：自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上equals 比较中所用的信息没有被修改...
复制链接

扫一扫