理解hashCode和equals的作用和区别

(4) 2024-05-02 16:23

Hi,大家好,我是编程小6,很荣幸遇见你,我把这些年在开发过程中遇到的问题或想法写出来,今天说一说理解hashCode和equals的作用和区别,希望能够帮助你!!!。

以前写程序一直没有注意hashCode的作用,一般都是覆盖了equals,缺没有覆盖hashCode,现在发现这是埋下了很多潜在的Bug!今天就来说一说hashCode和equals的作用。

       先来试想一个场景,如果你想查找一个集合中是否包含某个对象,那么程序应该怎么写呢?通常的做法是逐一取出每个元素与要查找的对象一一比较,当发现两者进行equals比较结果相等时,则停止查找并返回true,否则,返回false。但是这个做法的一个缺点是当集合中的元素很多时,譬如有一万个元素,那么逐一的比较效率势必下降很快。于是有人发明了一种哈希算法来提高从该集合中查找元素的效率,这种方式将集合分成若干个存储区域(可以看成一个个桶),每个对象可以计算出一个哈希码,可以根据哈希码分组,每组分别对应某个存储区域,这样一个对象根据它的哈希码就可以分到不同的存储区域(不同的桶中)。如下图所示:

                      理解hashCode和equals的作用和区别_https://bianchenghao6.com/blog__第1张                      理解hashCode和equals的作用和区别_https://bianchenghao6.com/blog__第2张

实际的使用中,一个对象一般有key和value,可以根据key来计算它的hashCode。假设现在全部的对象都已经根据自己的hashCode值存储在不同的存储区域中了,那么现在查找某个对象(根据对象的key来查找),不需要遍历整个集合了,现在只需要计算要查找对象的key的hashCode,然后找到该hashCode对应的存储区域,在该存储区域中来查找就可以了,这样效率也就提升了很多。说了这么多相信你对hashCode的作用有了一定的了解,下面就来看看hashCode和equals的区别和联系。

在研究这个问题之前,首先说明一下JDK对equals(Object obj)和hashCode()这两个方法的定义和规范:在Java中任何一个对象都具备equals(Object obj)和hashCode()这两个方法,因为他们是在Object类中定义的。 equals(Object obj)方法用来判断两个对象是否“相同”,如果“相同”则返回true,否则返回false。 hashCode()方法返回一个int数,在Object类中的默认实现是“将该对象的内部地址转换成一个整数返回”。 

下面是官方文档给出的一些说明:


    
    
    
    
  1. hashCode 的常规协定是:
  2. 在 Java 应用程序执行期间,在同一对象上多次调用 hashCode 方法时,必须一致地返回相同的整数,前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行,该整数无需保持一致。
  3. 如果根据 equals(Object) 方法,两个对象是相等的,那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。
  4. 以下情况不 是必需的:如果根据 equals(java.lang.Object) 方法,两个对象不相等,那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是,程序员应该知道,为不相等的对象生成不同整数结果可以提高哈希表的性能。
  5. 实际上,由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。(这一般是通过将该对象的内部地址转换成一个整数来实现的,但是 JavaTM 编程语言不需要这种实现技巧。)
  6. 当equals方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码。

下面是我查阅了相关资料之后对以上的说明做的归纳总结:

1.若重写了equals(Object obj)方法,则有必要重写hashCode()方法。

2.若两个对象equals(Object obj)返回true,则hashCode()有必要也返回相同的int数。

3.若两个对象equals(Object obj)返回false,则hashCode()不一定返回不同的int数。

4.若两个对象hashCode()返回相同int数,则equals(Object obj)不一定返回true。

5.若两个对象hashCode()返回不同int数,则equals(Object obj)一定返回false。

6.同一对象在执行期间若已经存储在集合中,则不能修改影响hashCode值的相关信息,否则会导致内存泄露问题。


想要弄清楚以上六点,先要知道什么时候需要重写equals和hashCode。一般来说涉及到对象之间的比较大小就需要重写equals方法,但是为什么第一点说重写了equals就需要重写hashCode呢?实际上这只是一条规范,如果不这样做程序也可以执行,只不过会隐藏bug。一般一个类的对象如果会存储在HashTable,HashSet,HashMap等散列存储结构中,那么重写equals后最好也重写hashCode,否则会导致存储数据的不唯一性(存储了两个equals相等的数据)。而如果确定不会存储在这些散列结构中,则可以不重写hashCode。但是个人觉得还是重写比较好一点,谁能保证后期不会存储在这些结构中呢,况且重写了hashCode也不会降低性能,因为在线性结构(如ArrayList)中是不会调用hashCode,所以重写了也不要紧,也为后期的修改打了补丁。

下面来看一张对象放入散列集合的流程图:

理解hashCode和equals的作用和区别_https://bianchenghao6.com/blog__第2张

理解hashCode和equals的作用和区别_https://bianchenghao6.com/blog__第4张

从上面的图中可以清晰地看到在存储一个对象时,先进行hashCode值的比较,然后进行equals的比较。可能现在你已经对上面的6点归纳有了一些认识。我们还可以通过JDK中得源码来认识一下具体hashCode和equals在代码中是如何调用的。

HashSet.java 


     
     
     
     
  1. public boolean add(E e) {
  2. return map.put(e, PRESENT)== null;
  3. }

HashMap.java


     
     
     
     
  1. public V put(K key, V value) {
  2. if (key == null)
  3. return putForNullKey(value);
  4. int hash = hash(key.hashCode());
  5. int i = indexFor(hash, table.length);
  6. for (Entry<K,V> e = table[i]; e != null; e = e.next) {
  7. Object k;
  8. if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
  9. V oldValue = e.value;
  10. e.value = value;
  11. e.recordAccess( this);
  12. return oldValue;
  13. }
  14. }
  15. modCount++;
  16. addEntry(hash, key, value, i);
  17. return null;
  18. }

最后再来看几个测试的例子吧:

测试一:覆盖equals(Object obj)但不覆盖hashCode(),导致数据不唯一性


    
    
    
    
  1. public class HashCodeTest {
  2. public static void main(String[] args) {
  3. Collection set = new HashSet();
  4. Point p1 = new Point( 1, 1);
  5. Point p2 = new Point( 1, 1);
  6. System.out.println(p1.equals(p2));
  7. set.add(p1); //(1)
  8. set.add(p2); //(2)
  9. set.add(p1); //(3)
  10. Iterator iterator = set.iterator();
  11. while (iterator.hasNext()) {
  12. Object object = iterator.next();
  13. System.out.println(object);
  14. }
  15. }
  16. }
  17. class Point {
  18. private int x;
  19. private int y;
  20. public Point(int x, int y) {
  21. super();
  22. this.x = x;
  23. this.y = y;
  24. }
  25. @Override
  26. public boolean equals(Object obj) {
  27. if ( this == obj)
  28. return true;
  29. if (obj == null)
  30. return false;
  31. if (getClass() != obj.getClass())
  32. return false;
  33. Point other = (Point) obj;
  34. if (x != other.x)
  35. return false;
  36. if (y != other.y)
  37. return false;
  38. return true;
  39. }
  40. @Override
  41. public String toString() {
  42. return "x:" + x + ",y:" + y;
  43. }
  44. }

输出结果:


    
    
    
    
  1. true
  2. x: 1,y: 1
  3. x: 1,y: 1

原因分析:

(1)当执行set.add(p1)时(1),集合为空,直接存入集合;

(2)当执行set.add(p2)时(2),首先判断该对象(p2)的hashCode值所在的存储区域是否有相同的hashCode,因为没有覆盖hashCode方法,所以jdk使用默认Object的hashCode方法,返回内存地址转换后的整数,因为不同对象的地址值不同,所以这里不存在与p2相同hashCode值的对象,因此jdk默认不同hashCode值,equals一定返回false,所以直接存入集合。

 (3)当执行set.add(p1)时(3),时,因为p1已经存入集合,同一对象返回的hashCode值是一样的,继续判断equals是否返回true,因为是同一对象所以返回true。此时jdk认为该对象已经存在于集合中,所以舍弃。

测试二:覆盖hashCode方法,但不覆盖equals方法,仍然会导致数据的不唯一性

修改Point类:


    
    
    
    
  1. class Point {
  2. private int x;
  3. private int y;
  4. public Point(int x, int y) {
  5. super();
  6. this.x = x;
  7. this.y = y;
  8. }
  9. @Override
  10. public int hashCode() {
  11. final int prime = 31;
  12. int result = 1;
  13. result = prime * result + x;
  14. result = prime * result + y;
  15. return result;
  16. }
  17. @Override
  18. public String toString() {
  19. return "x:" + x + ",y:" + y;
  20. }
  21. }

输出结果:


    
    
    
    
  1. false
  2. x: 1,y: 1
  3. x: 1,y: 1

原因分析:

(1)当执行set.add(p1)时(1),集合为空,直接存入集合;

(2)当执行set.add(p2)时(2),首先判断该对象(p2)的hashCode值所在的存储区域是否有相同的hashCode,这里覆盖了hashCode方法,p1和p2的hashCode相等,所以继续判断equals是否相等,因为这里没有覆盖equals,默认使用’==’来判断,所以这里equals返回false,jdk认为是不同的对象,所以将p2存入集合。

 (3)当执行set.add(p1)时(3),时,因为p1已经存入集合,同一对象返回的hashCode值是一样的,并且equals返回true。此时jdk认为该对象已经存在于集合中,所以舍弃。

综合上述两个测试,要想保证元素的唯一性,必须同时覆盖hashCode和equals才行。
(注意:在HashSet中插入同一个元素(hashCode和equals均相等)时,会被舍弃,而在HashMap中插入同一个Key(Value 不同)时,原来的元素会被覆盖。)

测试三:在内存泄露问题

     
     
     
     
  1. public class HashCodeTest {
  2. public static void main(String[] args) {
  3. Collection set = new HashSet();
  4. Point p1 = new Point( 1, 1);
  5. Point p2 = new Point( 1, 2);
  6. set.add(p1);
  7. set.add(p2);
  8. p2.setX( 10);
  9. p2.setY( 10);
  10. set.remove(p2);
  11. Iterator iterator = set.iterator();
  12. while (iterator.hasNext()) {
  13. Object object = iterator.next();
  14. System.out.println(object);
  15. }
  16. }
  17. }
  18. class Point {
  19. private int x;
  20. private int y;
  21. public Point(int x, int y) {
  22. super();
  23. this.x = x;
  24. this.y = y;
  25. }
  26. public int getX() {
  27. return x;
  28. }
  29. public void setX(int x) {
  30. this.x = x;
  31. }
  32. public int getY() {
  33. return y;
  34. }
  35. public void setY(int y) {
  36. this.y = y;
  37. }
  38. @Override
  39. public int hashCode() {
  40. final int prime = 31;
  41. int result = 1;
  42. result = prime * result + x;
  43. result = prime * result + y;
  44. return result;
  45. }
  46. @Override
  47. public boolean equals(Object obj) {
  48. if ( this == obj)
  49. return true;
  50. if (obj == null)
  51. return false;
  52. if (getClass() != obj.getClass())
  53. return false;
  54. Point other = (Point) obj;
  55. if (x != other.x)
  56. return false;
  57. if (y != other.y)
  58. return false;
  59. return true;
  60. }
  61. @Override
  62. public String toString() {
  63. return “x:” + x + “,y:” + y;
  64. }
  65. }

运行结果:


     
     
     
     
  1. x: 1,y: 1
  2. x: 10,y: 10


原因分析:

    假设p1的hashCode为1,p2的hashCode为2,在存储时p1被分配在1号桶中,p2被分配在2号筒中。这时修改了p2中与计算hashCode有关的信息(x和y),当调用remove(Object obj)时,首先会查找该hashCode值得对象是否在集合中。假设修改后的hashCode值为10(仍存在2号桶中),这时查找结果空,jdk认为该对象不在集合中,所以不会进行删除操作。然而用户以为该对象已经被删除,导致该对象长时间不能被释放,造成内存泄露。解决该问题的办法是不要在执行期间修改与hashCode值有关的对象信息,如果非要修改,则必须先从集合中删除,更新信息后再加入集合中。

总结:

1.hashCode是为了提高在散列结构存储中查找的效率,在线性表中没有作用。
2.equals和hashCode需要同时覆盖。
3.若两个对象equals返回true,则hashCode有必要也返回相同的int数。
4.若两个对象equals返回false,则hashCode不一定返回不同的int数,但为不相等的对象生成不同hashCode值可以提高
哈希表的性能。
5.若两个对象hashCode返回相同int数,则equals不一定返回true。
6.若两个对象hashCode返回不同int数,则equals一定返回false。
7.同一对象在执行期间若已经存储在集合中,则不能修改影响hashCode值的相关信息,否则会导致内存泄露问题。

原文章地址:理解hashCode和equals的作用和区别

今天的分享到此就结束了,感谢您的阅读,如果确实帮到您,您可以动动手指转发给其他人。

上一篇

已是最后文章

下一篇

已是最新文章

发表回复