equals()?==?hashCode()?今天就把你们都认识清楚

本文转载自微信公众号「java宝典」，作者iTengy。转载本文请联系java宝典公众号。 u

成都创新互联公司从2013年开始，是专业互联网技术服务公司，拥有项目网站建设、做网站网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元上城做网站,已为上家服务,为上城各地企业和个人服务,联系电话:13518219792

目录

  • Java中的数据类型
  • 什么时候用关系操作符==,什么时候用equals方法?
  • equals方法,为什么报了 空指针 java.lang.NullPointerException?
  • hashCode 方法有什么作用?hashCode 和 equals 的关系?
  • 为什么每个覆盖了equals方法的类中，也必须覆盖hashCode方法?

数据类型

java中的数据类型，可分为两类：

1.基本数据类型(原始数据类型)

byte,short,char,int,long,float,double,boolean 他们之间的比较，应用双等号(==),基础数据类型比较的是他们的值。

2.引用类型(类、接口、数组)

当他们用(==)进行比较的时候，比较的是他们在内存中的存放地址, 对象是放在堆中的，栈中存放的是对象的引用(地址)。由此可见'=='在比较的对象是引用类型时,是对栈中的地址值进行比较的。

关系操作符 ==

java中包含的关系操作符有小于(<)、大于(>)、小于或等于(<=)、大于或等于(>=)、等于(==)以及不等于(!=)。

==和!=适用所有对象，但是这两个操作符通常在比较对象的时候会出问题:

在这里==和!=比较的是对象的引用。尽管对象的内容相同，但是对象的引用却是不同的，说以n1==n2是false。

 
 
 
    
  
  
  
  1. Integer n1 = new Integer(47);
    2. 
  
  
  
  2.         Integer n2 = new Integer(47);
    3. 
  
  
  
  3.         
    4. 
  
  
  
  4.         System.out.println(n1 == n2);  //false
    5. 
  
  
  
  5.         System.out.println(n1 != n2);  //true
    6.

在这里 == 比较的是基本数据类型, 那么他会比较数值是否相等.所以此时 n1 == n2输出 true.

 
 
 
    
  
  
  
  1. int n1 = 100;
    2. 
  
  
  
  2.        int n2 = 100;
    3. 
  
  
  
  3. 
  
  
  
  4.        System.out.println(n1 == n2);  //true
    5. 
  
  
  
  5.        System.out.println(n1 != n2);  //false
    6.

equals方法

默认情况,对象的equals方法 调用的是Object类中equals方法.源码如下:

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

注意这里相当于还是用的==,在这里比较的是引用对象,所以是比较地址(是不是同一个对象)

第二种情况,重写了对象的equals方法. 例如String对象.源码如下:

 
 
 
    
  
  
  
  1. public boolean equals(Object anObject) {
    2. 
  
  
  
  2.         if (this == anObject) {
    3. 
  
  
  
  3.             return true;//如果是同一个对象直接返回
    4. 
  
  
  
  4.         }
    5. 
  
  
  
  5.         if (anObject instanceof String) {//是String对象开始判断内容.
    6. 
  
  
  
  6.             String anotherString = (String)anObject;
    7. 
  
  
  
  7.             int n = value.length;
    8. 
  
  
  
  8.             if (n == anotherString.value.length) {
    9. 
  
  
  
  9.                 char v1[] = value;
    10. 
  
  
  
  10.                 char v2[] = anotherString.value;
    11. 
  
  
  
  11.                 int i = 0;
    12. 
  
  
  
  12.                 while (n-- != 0) {//逐个字符比较，若有不相等字符，返回false
    13. 
  
  
  
  13.                     if (v1[i] != v2[i])
    14. 
  
  
  
  14.                         return false;
    15. 
  
  
  
  15.                     i++;
    16. 
  
  
  
  16.                 }
    17. 
  
  
  
  17.                 return true;
    18. 
  
  
  
  18.             }
    19. 
  
  
  
  19.         }
    20. 
  
  
  
  20.         return false;
    21. 
  
  
  
  21.     }
    22.

此时,equals方法的重写实现不尽相同,但是重写后一般都是通过对象的内容是否相等 来判断 对象是否相等,对于大多数Java类库都实现了equals()方法，以便用来比较对象的内容，而非比较对象的引用

避免equals方法,报空指针

避免equals方法报空指针,先告诉大家,答案是使用Objects.equals(a,b),在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的)，用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在默认情况下,对象的equals方法没有重写 调用的是Object类中equals方法

那么我们来写个报错的例子:

 
 
 
    
  
  
  
  1. A a = null;//假设我接收到config对象,我并不知道是否为空,就进行比较
    2. 
  
  
  
  2.         boolean r = a.equals(new B());
    3. 
  
  
  
  3.         System.out.println(r); //输出 java.lang.NullPointerException
    4.

此时由于我们的疏忽,接收到参数后,并没有对参数进行校验,导致调用equals方法报出空指针.

 
 
 
    
  
  
  
  1. //其它的例子有:
    2. 
  
  
  
  2. null.equals("java宝典");  //NullPointerException
    3. 
  
  
  
  3. 
  
  
  
  4. "java宝典".equals(null);  //false 只有equals左边的对象不为Null时,才有结果
    5. 
  
  
  
  5. 
  
  
  
  6. null.equals(null);  //NullPointerException
    7.

使用Objects.equals(a,b),左右 两边都为Null也不会报空指针

 
 
 
    
  
  
  
  1. Objects.equals(null,"java宝典");  //false
    2. 
  
  
  
  2. 
  
  
  
  3. Objects.equals("java宝典",null);  //false
    4. 
  
  
  
  4. 
  
  
  
  5. Objects.equals(null,null);  //true
    6.

看一下Objects.equals方法的源码,它是容忍空指针的

 
 
 
    
  
  
  
  1. public static boolean equals(Object a, Object b) {
    2. 
  
  
  
  2.        return (a == b) || (a != null && a.equals(b));
    3. 
  
  
  
  3.    }
    4.

hashCode() 方法

哈希(Hash)实际上是 人名，由于他提出一哈希算法的概念，所以就以他的名字命名了。哈希算法也称为散列算法，是指将数据依特定算法直接指定到一个地址上,通俗理解就是一种从任何一种数据中创建小的数字“指纹”的方法。

在java中,默认情况下,对象没有重写hashCode()方法.使用的是Object类中的.

 
 
 
    
  
  
  
  1. public native int hashCode(); //它是一个native方法.
    2.

Object 类定义的 hashCode 方法会针对不同的对象返回不同的整数。(这是通过将该对象的内部地址转换成一个整数来实现的)

例子:

 
 
 
    
  
  
  
  1. Config config1 = new Config();
    2. 
  
  
  
  2.        Config config2 = new Config();
    3. 
  
  
  
  3. 
  
  
  
  4.        System.out.println(config1.hashCode());  //1128032093
    5. 
  
  
  
  5. 
  
  
  
  6.        System.out.println(config2.hashCode());  //1066516207
    7. 
  
  
  
  7. 
  
  
  
  8.        System.out.println(config1.equals(config2));  //false
    9.

hashCode 和 equals 的关系

二者均是Object类里的方法,由于Object类是所有类的基类，所以一切类里都可以重写这两个方法。

  • 原则 1 ：如果 x.equals(y) 返回 “true”，那么 x 和 y 的 hashCode() 必须相等 ;
  • 原则 2 ：如果 x.equals(y) 返回 “false”，那么 x 和 y 的 hashCode() 有可能相等，也有可能不等 ;
  • 原则 3 ：如果 x 和 y 的 hashCode() 不相等，那么 x.equals(y) 一定返回 “false” ;
  • 原则 4 ：一般来讲，equals 这个方法是给用户调用的，而 hashcode 方法一般用户不会去调用 ;
  • 原则 5 ：当一个对象类型作为集合对象的元素时，那么这个对象应该拥有自己的equals()和hashCode()设计，而且要遵守前面所说的几个原则。

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

如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。

如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法 不要求 一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。

为什么每个覆盖了equals方法的类中，也必须覆盖hashCode方法?

在每个覆盖了equals方法的类中，也必须覆盖hashCode方法。如果不这样做的话，就会违反Object.hashCode的通用约定，从而导致该类无法结合所有基于散列的集合一起正常运作

上面我们介绍了hashCode是什么,进一步了解 hashCode 的应用，我们必须先要了解Java中的容器，因为 HashCode 只是在需要用到哈希算法的数据结构中才有用，比如 HashSet, HashMap ..

我们以hashMap为例:

HashMap是由数组和链表组成的存储数据的结构。确定一个数据存储在数组中的哪个位置 就是通过hashCode方法进行计算出存储在哪个位置， 产生冲突的话就会调用equals方法进行比对， 如果不同，那么就将其加入链表尾部，如果相同就替换原数据。计算位置当然不是上面简单的一个hashCode方法就计算出来，中间还有一些其他的步骤，这里可以简单的认为是hashCode确定了位置,代码如下:

 
 
 
    
  
  
  
  1. public V put(K key, V value) {
    2. 
  
  
  
  2.      // 如果哈希表没有初始化就进行初始化
    3. 
  
  
  
  3.      if (table == EMPTY_TABLE) {
    4. 
  
  
  
  4.          // 初始化哈希表
    5. 
  
  
  
  5.          inflateTable(threshold);
    6. 
  
  
  
  6.      }
    7. 
  
  
  
  7.   
    8. 
  
  
  
  8.      // 当key为null时，调用putForNullKey方法，保存null于table的第一个位置中，这是HashMap允许为null的原因
    9. 
  
  
  
  9.      if (key == null) {
    10. 
  
  
  
  10.          return putForNullKey(value);
    11. 
  
  
  
  11.      }
    12. 
  
  
  
  12.   
    13. 
  
  
  
  13.      // 计算key的hash值
    14. 
  
  
  
  14.      int hash = hash(key);
    15. 
  
  
  
  15.      // 根据key的hash值和数组的长度定位到entry数组的指定槽位
    16. 
  
  
  
  16.      int i = indexFor(hash, table.length);
    17. 
  
  
  
  17.      // 获取存放位置上的entry，如果该entry不为空，则遍历该entry所在的链表
    18. 
  
  
  
  18.      for (Entry e = table[i]; e != null; e = e.next) {
    19. 
  
  
  
  19.          Object k;
    20. 
  
  
  
  20.          // 通过key的hashCode和equals方法判断，key是否存在， 如果存在则用新的value取代旧的value，并返回旧的value
    21. 
  
  
  
  21.          if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
    22. 
  
  
  
  22.              V oldValue = e.value;
    23. 
  
  
  
  23.              e.value = value;
    24. 
  
  
  
  24.              e.recordAccess(this);
    25. 
  
  
  
  25.              return oldValue;
    26. 
  
  
  
  26.          }
    27. 
  
  
  
  27.      }
    28. 
  
  
  
  28.   
    29. 
  
  
  
  29.      // 修改次数增加1
    30. 
  
  
  
  30.      modCount++;
    31. 
  
  
  
  31.      // 如果找不到链表 或者 遍历完链表后，发现key不存在，则创建一个新的Entry，并添加到HashMap中
    32. 
  
  
  
  32.      addEntry(hash, key, value, i);
    33. 
  
  
  
  33.      return null;
    34. 
  
  
  
  34.  } 
    35.

在上面的方法中,调用了一个方法可以看到,数组的下标是根据传入的元素hashCode方法的返回值再和特定的值异或决定的:

 
 
 
    
  
  
  
  1. static int indexFor(int h, int length) {
    2. 
  
  
  
  2.         // 对hash值和length-1进行与运算来计算索引
    3. 
  
  
  
  3.         return h & (length - 1);
    4. 
  
  
  
  4.     }
    5.

再回到我们的问题:为什么每个覆盖了equals方法的类中，也必须覆盖hashCode方法?

如果你重写了equals， 而hashCode的实现不重写,那么类的hashcode方法就是Object默认的hashcode方法，由于默认的hashcode方法是根据对象的内存地址经哈希算法得来的一个值，那么很可能某两个对象明明是“相等”，而hashCode却不一样。

这样，当你用其中的一个作为键保存到hashMap、hasoTable或hashSet中，再以“相等的”找另一个作为键值去查找他们的时候 ，则根本找不到。导致HashSet、HashMap不能正常的运作.

比如：有个A类重写了equals方法，但是没有重写hashCode方法，对象a1和对象a2使用equals方法相等，按照上面的hashcode的用法，那么他们两个的hashcode肯定相等，但是这里由于没重写hashcode方法，他们两个hashcode并不一样，所以，我们在重写了equals方法后，尽量也重写了hashcode方法，通过一定的算法，使他们在equals相等时，也会有相同的hashcode值。

总结

== 在比较基本数据类型时,比较的是值

== 在比较引用数据类型时,比较的是对象的引用地址

对象的equals方法,在不重写的情况下,使用的是==,比较的是对象的引用地址

对象的equals方法,在重写以后,用于比较对象的内容是否相等,实现可以使用IDE生成或者自定义实现.(例如,String类对equals方法的重写就是逐个比较字符)

不重写的情况下,对象的equals方法 调用的是Object类中equals方法,在条件左边为Null时会报空指针,使用Objects.equals(a,b)可以避免空指针

hashcode是系统用来快速检索对象而使用的

重写了equals方法后，也要重写了hashcode方法,否则会导致HashSet、HashMap等依赖hashCode的容器不能正常的运作

分享文章：equals()?==?hashCode()?今天就把你们都认识清楚
标题路径：http://www.shufengxianlan.com/qtweb/news20/89320.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

标签优化知识

分类信息网站

温江电信机房　　 　圣月阀门　　 　重庆移动网站建设　　 　重庆教育培训网站建设　　 　网站运营　　 　成都网站营销　　 　手机网站制作　　 　青年旅行社　　 　自适应网页设计　　 　seo网络营销推广　　 　成都网站改版公司　　 　腾讯免备案主机　　 　成都响应式网站建设　　 　眉山服务器托管　　 　新华建筑装饰　　 　混凝土搅拌车　　 　成都h5建站开发　　 　江油做网站　　 　不锈钢防护栏　　 　成都多线机房