Java面向对象语法：equals和hashCode的区别详解

一、前言

前段时间使用list.remove(obj)的时候重写了obj的equals方法，因为list的remove是以equals来判断标准的。但是，今天被公司的代码扫描工具提示未重写hashCode方法！！之前准备面试时也多少看过，但是没有细细研究过这个hashCode和equals到底背后是什么个关系，趁此机会，总结一波。

本文章所用到的自定义测试对象类Stu：

public class Stu {
  private String name;
  private int age;

  Stu(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public String getName() {
    return name;
  }

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

  public int getAge() {
    return age;
  }

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

二、equals的具体作用

首先要说的是equals是Object的方法，所以只能用于对象间，基本类型之间比较用“==”，反则他们的封装类型可以用equals。

public static void main(String[] args) {
  Stu s1 = new Stu("张三", 18);
  Stu s2 = new Stu("张三", 18);
  System.out.println("stu:" + s1.equals(s2));

  Integer i1 = new Integer(18);
  Integer i2 = new Integer(18);
  System.out.println("Integer:" + i1.equals(i2));

  String str1 = "张三";
  String str2 = "张三";
  System.out.println("String:" + str1.equals(str2));
}

很简单，可以得到下面的结果：

stu:false
Integer:true
String:true

通过idea工具可以看到各自的equals实现代码：

Stu

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

Integer

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

String

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String) anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                        return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

Stu因为没有重写equals方法，所以直接使用的父类Object的equals方法，后面Integer和String都各自实现了自己的equals方法，所以Integer（基本类型）的equals实际上都是用的自己的实际值比较，String则是逐个char比较相等于否。

三、hashCode的具体作用

hashcode方法返回该对象的哈希码值。支持该方法是为哈希表提供一些优点，例如，java.util.Hashtable 提供的哈希表。

hashCode 的常规协定是：
在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。

以下情况不 是必需的：如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是，程序员应该知道，为不相等的对象生成不同整数结果可以提高哈希表的性能。

实际上，由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 JavaTM 编程语言不需要这种实现技巧。）

当equals方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。

上面是引用的官方文档上面的一段话，我们需要他说人话：

1. 对象equals方法参与运算的自身属性attr不能被修改，并且同一个对象的hashCode值任何时候的返回值都应该相等；
2. hashCode不等的两个对象equals一定不相等，但是hashCode相等的两个对象equals不一定相等；
3. 根据规定，重写对象的equals方法必须重写hashCode方法，尽管不写也能通过编译；

这里引用网上一个很容易理解的例子：

hashcode是用来查找的，如果你学过数据结构就应该知道，在查找和排序这一章有
例如内存中有这样的位置
0 1 2 3 4 5 6 7
而我有个类，这个类有个字段叫id,我要把这个类存放在以上8个位置之一，如果不用hashcode而任意存放，那么当查找时就需要到这八个位置里挨个去找，或者用二分法一类的算法。
但如果用hashCode那就会使效率提高很多。
我们这个类中有个字段叫id,那么我们就定义我们的hashCode为id％8，然后把我们的类存放在取得得余数那个位置。比如我们的ID为9，9除8的余数为1，那么我们就把该类存在1这个位置，如果ID是13，求得的余数是5，那么我们就把该类放在5这个位置。这样，以后在查找该类时就可以通过ID除 8求余数直接找到存放的位置了。

但是如果两个类有相同的hashCode怎么办那（我们假设上面的类的id不是唯一的），例如9除以8和17除以8的余数都是1，那么这是不是合法的，回答是：完全合法。那么如何判断呢？在这个时候就需要定义equals了。
也就是说，我们先通过 hashCode来判断两个类是否存放某个桶里，但这个桶里可能有很多类，那么我们就需要再通过 equals 来在这个桶里找到我们要的类。
那么。重写了equals()，为什么还要重写hashCode()呢？
想想，你要在一个桶里找东西，你必须先要找到这个桶啊，你不通过重写hashCode()来找到桶，光重写equals()有什么用啊。

可能太过文本的东西没有什么说服力，那就来点干货：

public static void main(String[] args) {
  Stu s1 = new Stu("张三", 18);
  Stu s2 = new Stu("张三", 18);
  System.out.println("stu:" + s1.equals(s2));

  Set<Stu> set = new HashSet<>();
  set.add(s1);
  System.out.println("s1 hashCode:" + s1.hashCode());
  System.out.println("add s1 size:" + set.size());
  set.add(s2);
  System.out.println("s2 hashCode:" + s2.hashCode());
  System.out.println("add s2 size::" + set.size());
}

输出结果：

stu:false
s1 hashCode:1317241155
add s1 size:1
s2 hashCode:463175162
add s2 size::2

Java中的Set是不允许有重复元素的，所以这里set的size由1变成了2，因为两个Stu都是new出来的，分配的地址不一样，那么Set是通过equals来定义重复的吗？

首先重写Stu的equals方法：

@Override
public boolean equals(Object obj) {
  if (obj == null){
    return false;
  }
  if (obj.getClass() != getClass()){
    return false;
  }
  return ((Stu)obj).getName().equals(getName());
}

输出结果：

stu:true
s1 hashCode:713679046
add s1 size:1
s2 hashCode:1107557627
add s2 size::2

重写equals方法，name相同就让equals返回true了，但是Set的size还是发生了改变，就说明不是有equals方法来定义重复的，现在仅仅重写hashCode方法：

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

输出结果：

stu:false
s1 hashCode:774889
add s1 size:1
s2 hashCode:774889
add s2 size::2

仅重写了hashCode方法，所以equals返回false，然后hashCode由name属性的hashCode方法得到，所以hashCode相等，但是Set的size还是改变了，这说明Set也不是仅仅依据hashCode来定义重复。

那么现在将上述equals和hashCode两者同时重写，输出结果：

stu:true
s1 hashCode:774889
add s1 size:1
s2 hashCode:774889
add s2 size::1

结合上面引用的案例，可以类推，hash类存储结构（HashSet、HashMap等等）添加元素会有重复性校验，校验的方式就是先取hashCode判断是否相等（找到对应的位置，该位置可能存在多个元素），然后再取equals方法比较（极大缩小比较范围，高效判断），最终判定该存储结构中是否有重复元素。

四、总结

1. hashCode主要用于提升查询效率，来确定在散列结构中对象的存储地址；
2. 重写equals()必须重写hashCode()，二者参与计算的自身属性字段应该相同；
3. hash类型的存储结构，添加元素重复性校验的标准就是先取hashCode值，后判断equals()；
4. equals()相等的两个对象，hashcode()一定相等；
5. 反过来：hashcode()不等，一定能推出equals()也不等；
6. hashcode()相等，equals()可能相等，也可能不等。

五、花边：通用的hashCode重写方案

初始化一个整形变量，为此变量赋予一个非零的常数值，比如int result = 17;
选取equals方法中用于比较的所有域，然后针对每个域的属性进行计算：

1. 如果是boolean值，则计算f ? 1:0
2. 如果是byte\char\short\int,则计算(int)f
3. 如果是long值，则计算(int)(f ^ (f >>> 32))
4. 如果是float值，则计算Float.floatToIntBits(f)
5. 如果是double值，则计算Double.doubleToLongBits(f)，然后返回的结果是long,再用规则(3)去处理long,得到int
6. 如果是对象应用，如果equals方法中采取递归调用的比较方式，那么hashCode中同样采取递归调用hashCode的方式。否则需要为这个域计算一个范式，比如当这个域的值为null的时候，那么hashCode 值为0
7. 如果是数组，那么需要为每个元素当做单独的域来处理。如果你使用的是1.5及以上版本的JDK，那么没必要自己去重新遍历一遍数组，java.util.Arrays.hashCode方法包含了8种基本类型数组和引用数组的hashCode计算，算法同上

给个简单的例子：

@Override
public int hashCode() {
  int result = 17;
  result = 31 * result + getName().hashCode();
  return result;
}

另外本人还开设了个人公众号：JiandaoStudio ，会在公众号内定期发布行业信息，以及各类免费代码、书籍、大师课程资源。

 

                                            

扫码关注本人微信公众号，有惊喜奥！公众号每天定时发送精致文章！回复关键词可获得海量各类编程开发学习资料！

例如：想获得Python入门至精通学习资料，请回复关键词Python即可。