重写Equals方法为什么通常会重写Hashcode方法?

开发 前端
最近在面试的时候,当问完了HashMap的数据结构之后,通常会再多问一个问题,就是:重写equals方法时通常为什么也要重写一下hashcode方法?

[[388535]]

本文转载自微信公众号「程序新视界」,作者二师兄。转载本文请联系程序新视界公众号。  

最近在面试的时候,当问完了HashMap的数据结构之后,通常会再多问一个问题,就是:重写equals方法时通常为什么也要重写一下hashcode方法?

其实这个问题,本质上又回到HashMap的应用场景了,就是想看一下面试者是否真的融会贯通。今天这篇文章就带大家了解一下equals方法和hashcode方法之间的关系,以及相关的知识点。

equals与hashcode的存在

其实每个类都有一个equals方法和hashcode方法。因为所有的类都继承自Object类。Object类中定义如下:

  1. public boolean equals(Object obj) { 
  2.     return (this == obj); 
  3.      
  4. public native int hashCode(); 

直观上可以看到equals方法默认比较的是对象的引用,直接用“==”进行比较。而hashCode方法是一个native方法,返回值为整型。

而这两个方法都未被final修饰,都是可以进行重写的。

对于我们经常使用的比如String 、Math、Integer、Double等类,都进行了equals()和hashCode()方法的重写。

equals()方法

equals()方法是用来判断两个对象是否相等。Object默认实现了equals方法,但很明显不太符合个性化的需求,因此往往需要进行重写。比如常用的String类,重写的equals方法如下:

  1. // 重写equals方法 
  2. public boolean equals(Object anObject) { 
  3.     if (this == anObject) { 
  4.         return true
  5.     } 
  6.     if (anObject instanceof String) { 
  7.         String anotherString = (String)anObject; 
  8.         int n = value.length; 
  9.         if (n == anotherString.value.length) { 
  10.             char v1[] = value; 
  11.             char v2[] = anotherString.value; 
  12.             int i = 0; 
  13.             while (n-- != 0) { 
  14.                 if (v1[i] != v2[i]) 
  15.                     return false
  16.                 i++; 
  17.             } 
  18.             return true
  19.         } 
  20.     } 
  21.     return false

这里的比较已不再是单纯的地址比较了。首先通过地址进行比较,如果地址相同那么肯定是相同的对象。如果地址不同就再拿char数组的内容进行比较,完全相等则返回true。

equals()方法的特质

在Object类的equals方法上有注释说明了equals()方法需满足的一些特性:

  • 自反性(reflexive)。对于任意不为null的引用值x,x.equals(x)一定是true;
  • 对称性(symmetric)。对于任意不为null的引用值x和y,当且仅当x.equals(y)是true时,y.equals(x)也是true;
  • 传递性(transitive)。对于任意不为null的引用值x、y和z,如果x.equals(y)是true,同时y.equals(z)是true,那么x.equals(z)一定是true;
  • 一致性(consistent)。对于任意不为null的引用值x和y,如果用于equals比较的对象信息没有被修改的话,多次调用时x.equals(y)要么一致地返回true要么一致地返回false;
  • 对于任意不为null的引用值x,x.equals(null)返回false;

对照上面特质,我们发现Object方法直接比较的是两个引用地址,只有两个地址相同才相等,也就是说是差别可能性最大的等价关系。

而String的equals方法,不仅包含应用地址相同这种情况,还包括里面所存储的字符串值相同的情况。也就是说虽然是两个String对象,但是它们的字符串值相等,那么equals方法返回的结果就是true。这也正是大多数情况下我们所说的“equals方法比较的是值”。

由于Object的equals方法的默认特例存在,因此在没有自定义equals方法时,我们不能一概的说equals方法比较的是具体的值,而“==”比较的是引用。

hashCode()方法

hashCode()方法返回对象的一个hash code值。该方法被用于hash tables,如HashSet、HashMap。

hashCode()是一个native方法,返回值类型是整形,并且可以被重写。

Object中的native hashCode()方法将对象在内存中的地址作为哈希码返回,可以保证不同对象的返回值不同。

还以String类为例,它的hashCode方法为:

  1. // 重写hashCode方法 
  2. public int hashCode() { 
  3.     int h = hash; 
  4.     if (h == 0 && value.length > 0) { 
  5.         char val[] = value; 
  6.  
  7.         for (int i = 0; i < value.length; i++) { 
  8.             h = 31 * h + val[i]; 
  9.         } 
  10.         hash = h; 
  11.     } 
  12.     return h; 

上述hash值的计算注释中有说明,基本公式为:s[0]*31^(n-1) + s[1]*31^(n-2) + … + s[n-1]。

其中, s[i]是字符串的第i个字符,n是字符串的长度,^表示求幂(空字符串的哈希码为0)。

计算过程中使用数字31,主要有以下原因:

1、由于质数的特性,它与其他数字相乘之后,计算结果唯一的概率更大,哈希冲突的概率更小。

2、使用的质数越大,哈希冲突的概率越小,但是计算的速度也越慢;31是哈希冲突和性能的折中,实际上是实验观测的结果。

3、JVM会自动对31进行优化:31 * i == (i << 5) - i;

hashCode()方法的作用

前面提到hashCode()方法主要用于hash表中,比如HashSet、HashMap等。

我们先来看一下ArrayList,它的底层是数组,每个数据往底层的数组中存取即可,数据不需要判断是否重复。

集合Set中的元素是无序不可重复的,那么如何确保存入的元素不重复呢?逐个调用equals()方法进行比较?数据量少的时候还可以,但数据量大了时间复杂度基本上是O(n),会出现性能问题。

Java中采用哈希算法来解决这个问题,将对象(或数据)依特定算法直接映射到一个地址上,这样时间复杂度趋于O(1),对象的存取效率大大提高。

集合Set添加某元素时,先调用hashCode()方法,定位到此元素实际存储位置,如果这个位置没有元素,说明是第一次存储;若此位置有对象存在,调用equals()进行比较,相等就舍弃此元素不存,不等则散列到其他地址。

上面的示例也说明了为什么equals()相等,则hashCode()必须相等,进而当重写了equals方法,也要对hashCode()方法进行重写。

HashMap的基本处理机制与HashSet很类似,只不过底层的数据存储结构有所不同而已。

简而言之,在集合查找时,hashcode能极大的降低对象比较次数,提高查找效率。

hashCode()方法的性质

hashCode的实现也有一定的要求,相关英文说明在Object的equals方法注解上:

  • 在一个Java应用的执行期间,如果一个对象提供给equals做比较的信息没有被修改的话,该对象多次调用hashCode()方法,该方法必须始终如一返回同一个integer。
  • 如果两个对象根据equals(Object)方法是相等的,那么调用二者各自的hashCode()方法必须产生同一个integer结果。
  • 并不要求根据equals(java.lang.Object)方法不相等的两个对象,调用二者各自的hashCode()方法必须产生不同的integer结果。但对于不同的对象产生不同的integer结果,有可能会提高hash table的性能。

如何重写hashCode()

《Effective Java》中提供了一种简单通用的hashCode算法。

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

B、选取equals方法中用于比较的所有域(之所以只选择equals()中使用的域,是为了保证上述原则的第1条),然后针对每个域的属性进行计算:

  • (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) 如果是数组,那么需要为每个元素当做单独的域来处理。java.util.Arrays.hashCode方法包含了8种基本类型数组和引用数组的hashCode计算,算法同上。

C、最后,把每个域的散列码合并到对象的哈希码中。

小结

关于equals方法很明确的是用于比较两个对象是否相等。而对于hashCode方法重点是为了在类似HashMap场景下提升效率,只算是技术要求。

在集合中通常通过equals方法来比较对象是否相等,通过hashCode方法来解决大数据量时会发生的性能问题。

在实践中我们很少使用Object对象来作为Map的key,也是因为如果Object对象的属性变了,会导致hashCode变化,进而可能会导致找不到对应值,而String是不可变的对象,作为key就很适合。

参考文章:

https://www.cnblogs.com/kismetv/p/7191736.html

https://www.iteye.com/blog/kakajw-935226

https://www.iteye.com/blog/bijian1013-1972404

责任编辑:武晓燕 来源: 程序新视界
相关推荐

2021-07-30 09:32:55

JavaEquals

2019-08-16 10:10:07

hashcodeequalsJava

2021-12-03 06:59:23

HashCodeEquals面试

2021-12-13 09:10:48

equalshashCodeJava

2023-10-08 07:13:19

equalshashCode哈希表

2021-07-13 06:42:58

JavaEquals方法

2009-10-13 14:38:15

.NET重写URL

2022-01-11 06:53:23

面试重写重载

2021-01-26 12:14:40

Windows 10Windows微软

2021-12-30 19:36:48

GoDubboJava

2022-01-07 14:05:33

DubboGoJava

2015-10-10 10:36:00

warning category

2009-12-30 15:26:02

Silverlight

2009-09-04 11:35:05

C#方法重写

2015-07-27 15:27:11

程序员重写代码

2015-07-28 10:28:54

程序员代码

2018-05-07 15:59:39

代码程序员重写

2019-11-08 13:57:53

程序员Excel软件

2021-04-08 11:46:41

String hashJava代码

2022-12-28 09:10:44

HashMapImmutable类型
点赞
收藏

51CTO技术栈公众号