equals和hashCode的区别和联系

最新推荐文章于 2024-09-16 19:41:32 发布

~石头

最新推荐文章于 2024-09-16 19:41:32 发布

阅读量1.2k

点赞数

分类专栏： Java 文章标签： java 数据结构

本文链接：https://blog.csdn.net/qq_31868149/article/details/107025634

版权

Java 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

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 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。

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

对象equals方法参与运算的自身属性attr不能被修改，并且同一个对象的hashCode值任何时候的返回值都应该相等；
hashCode不等的两个对象equals一定不相等，但是hashCode相等的两个对象equals不一定相等；
根据规定，重写对象的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方法比较（极大缩小比较范围，高效判断），最终判定该存储结构中是否有重复元素。

四、总结

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

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

初始化一个整形变量，为此变量赋予一个非零的常数值，比如int result = 17;

选取equals方法中用于比较的所有域，然后针对每个域的属性进行计算：

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

java.util.Arrays.hashCode方法包含了8种基本类型数组和引用数组的hashCode计算，算法同上，

　　java.util.Arrays.hashCode(long[])的具体实现:

public static int hashCode(long a[]) {

if (a == null)

return 0;

int result = 1;

for (long element : a) {

int elementHash = (int)(element ^ (element >>> 32));

result = 31 * result + elementHash;

}

return result;

}