java中hashcode和equals的区别和联系

hashcode和equals的区别和联系

　　HashSet和HashMap一直都是JDK中最常用的两个类，HashSet要求不能存储相同的对象，HashMap要求不能存储相同的键。 那么Java运行时环境是如何判断HashSet中相同对象、HashMap中相同键的呢？当存储了“相同的东西”之后Java运行时环境又将如何来维护呢？ 

　　在研究这个问题之前，首先说明一下JDK对equals(Object obj)和hashcode()这两个方法的定义和规范：在Java中任何一个对象都具备equals(Object obj)和hashcode()这两个方法，因为他们是在Object类中定义的。

 　　equals(Object obj)方法用来判断两个对象是否“相同”，如果“相同”则返回true，否则返回false。

　　hashcode()方法返回一个int数，在Object类中的默认实现是“将该对象的内部地址转换成一个整数返回”。

　　接下来有两个个关于这两个方法的重要规范(我只是抽取了最重要的两个,其实不止两个)： 

　　规范1：若重写equals(Object obj)方法，有必要重写hashcode()方法，确保通过equals(Object obj)方法判断结果为true的两个对象具备相等的hashcode()返回值。说得简单点就是：“如果两个对象相同，那么他们的hashcode应该 相等”。不过请注意：这个只是规范，如果你非要写一个类让equals(Object obj)返回true而hashcode()返回两个不相等的值，编译和运行都是不会报错的。不过这样违反了Java规范，程序也就埋下了BUG。 

　　规范2：如果equals(Object obj)返回false，即两个对象“不相同”，并不要求对这两个对象调用hashcode()方法得到两个不相同的数。说的简单点就是：“如果两个对象不相同，他们的hashcode可能相同”。

　　根据这两个规范，可以得到如下推论：

　　1、如果两个对象equals，Java运行时环境会认为他们的hashcode一定相等。

　　2、如果两个对象不equals，他们的hashcode有可能相等。

　　3、如果两个对象hashcode相等，他们不一定equals。

　　4、如果两个对象hashcode不相等，他们一定不equals。 

这样我们就可以推断Java运行时环境是怎样判断HashSet和HastMap中的两个对象相同或不同了。即：先判断hashcode是否相等，再判断是否equals。 

　　'=='是用来比较两个变量（基本类型和对象类型）的值是否相等的， 如果两个变量是基本类型的，那很容易，直接比较值就可以了。如果两个变量是对象类型的，那么它还是比较值，只是它比较的是这两个对象在栈中的引用（即地址）。 对象是放在堆中的，栈中存放的是对象的引用（地址）。由此可见'=='是对栈中的值进行比较的。如果要比较堆中对象的内容是否相同，那么就要重写equals方法了。

　　Object类中的equals方法就是用'=='来比较的，所以如果没有重写equals方法，equals和==是等价的。 通常我们会重写equals方法，让equals比较两个对象的内容，而不是比较对象的引用（地址）因为往往我们觉得比较对象的内容是否相同比比较对象的引用（地址）更有意义。

　　Object类中的hashCode是返回对象在内存中地址转换成的一个int值（可以就当做地址看）。所以如果没有重写hashCode方法，任何对象的hashCode都是不相等的。通常在集合类的时候需要重写hashCode方法和equals方法，因为如果需要给集合类（比如：HashSet）添加对象，那么在添加之前需要查看给集合里是否已经有了该对象，比较好的方式就是用hashCode。

　　注意的是String、Integer、Boolean、Double等这些类都重写了equals和hashCode方法，这两个方法是根据对象的内容来比较和计算hashCode的。（详细可以查看jdk下的String.java源代码），所以只要对象的基本类型值相同，那么hashcode就一定相同。

hashCode方法的作用：

　　有许多人学了很长时间的Java，但一直不明白hashCode方法的作用，我来解释一下吧。首先，想要明白hashCode的作用，你必须要先知道Java中的集合。

　　总的来说，Java中的集合（Collection）有两类，一类是List，再有一类是Set。你知道它们的区别吗？前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。那么这里就有一个比较严重的问题了：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？这就是Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。

　　于是，Java采用了哈希表的原理。哈希（Hash）实际上是个人名，由于他提出一哈希算法的概念，所以就以他的名字命名了。哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。如果详细讲解哈希算法，那需要更多的文章篇幅，我在这里就不介绍了。初学者可以这样理解，hashCode方法实际上返回的就是对象存储的物理地址（实际可能并不是）。这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

　　所以，Java对于eqauls方法和hashCode方法是这样规定的：1、如果两个对象相同，那么它们的hashCode值一定要相同；2、如果两个对象的hashCode相同，它们并不一定相同    上面说的对象相同指的是用eqauls方法比较。

　　每当需要对比的时候，首先用hashCode()去对比，如果hashCode()不一样，则表示这两个对象肯定不相等（也就是不必再用equal()去再对比了）,如果hashCode()相同，此时再对比他们的equals()，如果equals()也相同，则表示这两个对象是真的相同了，这样既能大大提高了效率也保证了对比的正确性！ 

　　你当然可以不按要求去做了，但你会发现，相同的对象可以出现在Set集合中。同时，增加新元素的效率会大大下降。

当重写equals方法，必须重写hashCode方法吗？

不是必须的，得看具体的情况。

• 当equals方法返回的结果和使用等号比较的结果是一致的时候，是没有必要重写hashCode方法。

　　当用等号比较对象，只有是内存中同一个对象实例，才会返回true，当然调用其hashCode（）方法肯定返回相同的值，这满足了hashCode的约束条件，所以不用重写hashCode（）方法。

• 当equals方法返回的结果和使用等号比较的结果是不一致的时候，就需要重写hashCode方法。

　　当重写后的equals方法不认为只有是在内存中同一个对象实例，才返回true，如果不重新hashCode方法（）（Object的hashCode（）方法 是对内存地址的映射），hashCode方法返回的值肯定是不同的，这违背了hashCode的约束条件，所以必须要重新hashCode方法，并满足对hashCode的约束条件。

　　必须确保当我们使用equals判断是相等的对象，就应该拥有相同的hashCode。反之，当equals判断为不相等的对象其hashCode也应该不相等。所以我们同时重写equals方法和hashCode方法就是为了保证这一点。

如何重写对象的 equals 方法和 hashCode 方法

对比两个对象是否相等。对于下面的 User 对象，只需姓名和年龄相等则认为是同一个对象。

需要重写对象的 equals 方法和 hashCode 方法

package com.yule.user.entity;

import org.springframework.util.StringUtils;

/**
 * 用户实体
 *
 * @author yule
 * @date 2018/8/6 21:51
 */
public class User {
    private String id;
    private String name;
    private String age;

    public User(){

    }

    public User(String id, String name, String age){
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return this.id + " " + this.name + " " + this.age;
    }

    @Override
    public boolean equals(Object obj) {
        if(this == obj){
            return true;//地址相等
        }

        if(obj == null){
            return false;//非空性：对于任意非空引用x，x.equals(null)应该返回false。
        }

        if(obj instanceof User){
            User other = (User) obj;
            //需要比较的字段相等，则这两个对象相等
            if(equalsStr(this.name, other.name)
                    && equalsStr(this.age, other.age)){
                return true;
            }
        }

        return false;
    }

    private boolean equalsStr(String str1, String str2){
        if(StringUtils.isEmpty(str1) && StringUtils.isEmpty(str2)){
            return true;
        }
        if(!StringUtils.isEmpty(str1) && str1.equals(str2)){
            return true;
        }
        return false;
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + (name == null ? 0 : name.hashCode());
        result = 31 * result + (age == null ? 0 : age.hashCode());
        return result;
    }
}

测试：

创建两个对象，名字和年龄相等则对象 equals 为 true。

@Test
    public void testEqualsObj(){
        User user1 = new User("1", "xiaohua", "14");
        User user2 = new User("2", "xiaohua", "14");
        System.out.println((user1.equals(user2)));//打印为 true
    }

为什么要重写 equals 方法

　　因为不重写 equals 方法，执行 user1.equals(user2) 比较的就是两个对象的地址（即 user1 == user2），肯定是不相等的，见 Object 源码：

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

如何重写 hashCode

　　生成一个 int 类型的变量 result，并且初始化一个值，比如17

　　对类中每一个重要字段，也就是影响对象的值的字段，也就是 equals 方法里有比较的字段，进行以下操作：a. 计算这个字段的值 filedHashValue = filed.hashCode(); b. 执行 result = 31 * result + filedHashValue;

为什么要使用 31

看一看 String hashCode 方法的源码：

/**
     * Returns a hash code for this string. The hash code for a
     * {@code String} object is computed as
     * <blockquote><pre>
     * s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
     * </pre></blockquote>
     * using {@code int} arithmetic, where {@code s[i]} is the
     * <i>i</i>th character of the string, {@code n} is the length of
     * the string, and {@code ^} indicates exponentiation.
     * (The hash value of the empty string is zero.)
     *
     * @return  a hash code value for this object.
     */
    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

可以从注释看出：空字符串的 hashCode 方法返回是 0。并且注释中也给了个公式，可以了解了解。

String 源码中也使用的 31，然后网上说有这两点原因：

原因一：更少的乘积结果冲突

　　31是质子数中一个“不大不小”的存在，如果你使用的是一个如2的较小质数，那么得出的乘积会在一个很小的范围，很容易造成哈希值的冲突。而如果选择一个100以上的质数，得出的哈希值会超出int的最大范围，这两种都不合适。而如果对超过 50,000 个英文单词（由两个不同版本的 Unix 字典合并而成）进行 hash code 运算，并使用常数 31, 33, 37, 39 和 41 作为乘子，每个常数算出的哈希值冲突数都小于7个（国外大神做的测试），那么这几个数就被作为生成hashCode值得备选乘数了。

　　所以从 31,33,37,39 等中间选择了 31 的原因看原因二。

原因二：31 可以被 JVM 优化

　　JVM里最有效的计算方式就是进行位运算了：

　　* 左移 << : 左边的最高位丢弃，右边补全0（把 << 左边的数据*2的移动次幂）。
　　* 右移 >> : 把>>左边的数据/2的移动次幂。
　　* 无符号右移 >>> : 无论最高位是0还是1，左边补齐0。 　　

       所以 ： 31 * i = (i << 5) - i（左边  31*2=62,右边   2*2^5-2=62） - 两边相等，JVM就可以高效的进行计算啦。。。

此外，hashCode方法可以简单重写为：

@Override
    public int hashCode() {
        return Objects
                .hash(name,age);
    }

Objects.hash()源码：

public static int hashCode(Object a[]) {
        if (a == null)
            return 0;

        int result = 1;

        for (Object element : a)
            result = 31 * result + (element == null ? 0 : element.hashCode());

        return result;
    }

 

 

 

参考文章：

https://www.cnblogs.com/xiohao/p/4199446.html

https://www.cnblogs.com/yuxiaole/p/9570850.html