zoukankan      html  css  js  c++  java

  • 为什么要同时重写equals和hashcode

    原文地址https://blog.csdn.net/tiantiandjava/article/details/46988461

    原文地址https://blog.csdn.net/lijiecao0226/article/details/24609559

    知乎文章https://www.zhihu.com/question/26872848  这篇直呼文章很重要！！！！-------------------- ==，equals的区别

    首先来区分Java中 ==，equals，hashCode的区别

    ==是运算符，用于比较两个变量是否相等。

    equals，是Objec类的方法，用于比较两个对象是否相等，默认Object类的equals方法是比较两个对象的地址，跟==的结果一样。Object的equals方法如下：

    [java] view plain copy
     
    1. public boolean equals(Object obj) {  
    2.     return (this == obj);  
    3. }  


    hashCode也是Object类的一个方法。返回一个离散的int型整数。在集合类操作中使用，为了提高查询速度。（HashMap，HashSet等）

    有了这三个基础概念，区别就简单了。网上有很多，汇总一下：

    java中的数据类型，可分为两类： 
    1.基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean 
      他们之间的比较，应用双等号（==）,比较的是他们的值。 
    2.复合数据类型(类) 
      当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
      对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。

    如果两个对象根据equals()方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。
    如果两个对象根据equals()方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生相同的整数结果

    从而在集合操作的时候有如下规则：

    将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。

    回过来说get的时候，HashMap也先调key.hashCode()算出数组下标，然后看equals如果是true就是找到了，所以就涉及了equals。

    《Effective Java》书中有两条是关于equals和hashCode的：

    覆盖equals时需要遵守的通用约定： 
      覆盖equals方法看起来似乎很简单，但是如果覆盖不当会导致错误，并且后果相当严重。《Effective Java》一书中提到“最容易避免这类问题的办法就是不覆盖equals方法”，这句话貌似很搞笑，其实想想也不无道理，其实在这种情况下，类的每个实例都只与它自身相等。如果满足了以下任何一个条件，这就正是所期望的结果： 
    类的每个实例本质上都是唯一的。对于代表活动实体而不是值的类来说却是如此，例如Thread。Object提供的equals实现对于这些类来说正是正确的行为。
    不关心类是否提供了“逻辑相等”的测试功能。假如Random覆盖了equals，以检查两个Random实例是否产生相同的随机数序列，但是设计者并不认为客户需要或者期望这样的功能。在这样的情况下，从Object继承得到的equals实现已经足够了。
    超类已经覆盖了equals，从超类继承过来的行为对于子类也是合适的。大多数的Set实现都从AbstractSet继承equals实现，List实现从AbstractList继承equals实现，Map实现从AbstractMap继承equals实现。
    类是私有的或者是包级私有的，可以确定它的equals方法永远不会被调用。在这种情况下，无疑是应该覆盖equals方法的，以防止它被意外调用：
    @Override 
    public boolean equals(Object o){ 
      throw new AssertionError(); //Method is never called 
    } 

      在覆盖equals方法的时候，你必须要遵守它的通用约定。下面是约定的内容，来自Object的规范[JavaSE6] 
    自反性。对于任何非null的引用值x，x.equals(x)必须返回true。
    对称性。对于任何非null的引用值x和y，当且仅当y.equals(x)返回true时，x.equals(y)必须返回true
    传递性。对于任何非null的引用值x、y和z，如果x.equals(y)返回true，并且y.equals(z)也返回true，那么x.equals(z)也必须返回true。
    一致性。对于任何非null的引用值x和y，只要equals的比较操作在对象中所用的信息没有被修改，多次调用该x.equals(y)就会一直地返回true，或者一致地返回false。
    对于任何非null的引用值x，x.equals(null)必须返回false。

      结合以上要求，得出了以下实现高质量equals方法的诀窍： 
    1.使用==符号检查“参数是否为这个对象的引用”。如果是，则返回true。这只不过是一种性能优化，如果比较操作有可能很昂贵，就值得这么做。 
    2.使用instanceof操作符检查“参数是否为正确的类型”。如果不是，则返回false。一般来说，所谓“正确的类型”是指equals方法所在的那个类。 
    3.把参数转换成正确的类型。因为转换之前进行过instanceof测试，所以确保会成功。 
    4.对于该类中的每个“关键”域，检查参数中的域是否与该对象中对应的域相匹配。如果这些测试全部成功，则返回true;否则返回false。 
    5.当编写完成了equals方法之后，检查“对称性”、“传递性”、“一致性”。 

    覆盖equals时总要覆盖hashCode 的原因：
      一个很常见的错误根源在于没有覆盖hashCode方法。在每个覆盖了equals方法的类中，也必须覆盖hashCode方法。如果不这样做的话，就会违反Object.hashCode的通用约定，从而导致该类无法结合所有基于散列的集合一起正常运作，这样的集合包括HashMap、HashSet和Hashtable。

    比如将两个对象存入HashSet里面：如果不重写hashCode，还用原来的hashCode就可能判断两个对象的hashCode不相等（其实重写hashCode再判断这两个对象才发现这两个对象的hashCode是相等的），然后因为判断这两个对象的hashCode不相等就会直接将这两个对象存入HashSet，这就导致了实际上存入了这两个相同的对象。


    在应用程序的执行期间，只要对象的equals方法的比较操作所用到的信息没有被修改，那么对这同一个对象调用多次，hashCode方法都必须始终如一地返回同一个整数。在同一个应用程序的多次执行过程中，每次执行所返回的整数可以不一致。
    如果两个对象根据equals()方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。
    如果两个对象根据equals()方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生相同的整数结果。但是程序员应该知道，给不相等的对象产生截然不同的整数结果，有可能提高散列表的性能。

    ========================================================================================================================

    ========================================================================================================================

    ========================================================================================================================

    ========================================================================================================================

                                                                                          最好同时重写equals和hashcode的原因

    最近去面试了几家公司，被问到hashCode的作用，虽然回答出来了，但是自己还是对hashCode和equals的作用一知半解的，所以决定把它们研究一下。

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

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

                                                

    实际的使用中，一个对象一般有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类中的默认实现是“将该对象的内部地址转换成一个整数返回”。 

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

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


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

    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的比较。可能现在你已经对上面的6点归纳有了一些认识。我们还可以通过JDK中得源码来认识一下具体hashCode和equals在代码中是如何调用的。

    HashSet.java 

    [java] view plain copy
     
    1. <span style="font-size:18px;">  public boolean add(E e) {  
    2.     return map.put(e, PRESENT)==null;  
    3.     }</span>  

    HashMap.java
    [java] view plain copy
     
    1. <span style="font-size:18px;">    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.   
    16.         modCount++;  
    17.         addEntry(hash, key, value, i);  
    18.         return null;  
    19.     }</span>  


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

    测试一：覆盖equals（Object obj）但不覆盖hashCode（）,导致数据不唯一性

    [java] view plain copy
     
    1. <span style="font-size:18px;">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.   
    7.         System.out.println(p1.equals(p2));  
    8.         set.add(p1);   //(1)  
    9.         set.add(p2);   //(2)  
    10.         set.add(p1);   //(3)  
    11.   
    12.         Iterator iterator = set.iterator();  
    13.         while (iterator.hasNext()) {  
    14.             Object object = iterator.next();  
    15.             System.out.println(object);  
    16.         }  
    17.     }  
    18. }  
    19.   
    20. class Point {  
    21.     private int x;  
    22.     private int y;  
    23.   
    24.     public Point(int x, int y) {  
    25.         super();  
    26.         this.x = x;  
    27.         this.y = y;  
    28.     }  
    29.   
    30.     @Override  
    31.     public boolean equals(Object obj) {  
    32.         if (this == obj)  
    33.             return true;  
    34.         if (obj == null)  
    35.             return false;  
    36.         if (getClass() != obj.getClass())  
    37.             return false;  
    38.         Point other = (Point) obj;  
    39.         if (x != other.x)  
    40.             return false;  
    41.         if (y != other.y)  
    42.             return false;  
    43.         return true;  
    44.     }  
    45.   
    46.     @Override  
    47.     public String toString() {  
    48.         return "x:" + x + ",y:" + y;  
    49.     }  
    50.   
    51. }  
    52. </span>  



    输出结果：

    [java] view plain copy
     
    1. <span style="font-size:18px;">true  
    2. x:1,y:1  
    3. x:1,y:1  
    4. </span>  


    原因分析：

    （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类：

    [java] view plain copy
     
    1. <span style="font-size:18px;">class Point {  
    2.     private int x;  
    3.     private int y;  
    4.   
    5.     public Point(int x, int y) {  
    6.         super();  
    7.         this.x = x;  
    8.         this.y = y;  
    9.     }  
    10.   
    11.     @Override  
    12.     public int hashCode() {  
    13.         final int prime = 31;  
    14.         int result = 1;  
    15.         result = prime * result + x;  
    16.         result = prime * result + y;  
    17.         return result;  
    18.     }  
    19.   
    20.     @Override  
    21.     public String toString() {  
    22.         return "x:" + x + ",y:" + y;  
    23.     }  
    24.   
    25. }  
    26. </span>  


    输出结果：

    [java] view plain copy
     
    1. <span style="font-size:18px;">false  
    2. x:1,y:1  
    3. x:1,y:1</span>  

    原因分析：

    （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 不同）时，原来的元素会被覆盖。）
     
    测试三：在内存泄露问题
    [java] view plain copy
     
    1. <span style="font-size:18px;">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.   
    7.         set.add(p1);  
    8.         set.add(p2);  
    9.           
    10.         p2.setX(10);  
    11.         p2.setY(10);  
    12.           
    13.         set.remove(p2);  
    14.   
    15.         Iterator iterator = set.iterator();  
    16.         while (iterator.hasNext()) {  
    17.             Object object = iterator.next();  
    18.             System.out.println(object);  
    19.         }  
    20.     }  
    21. }  
    22.   
    23. class Point {  
    24.     private int x;  
    25.     private int y;  
    26.   
    27.     public Point(int x, int y) {  
    28.         super();  
    29.         this.x = x;  
    30.         this.y = y;  
    31.     }  
    32.   
    33.   
    34.     public int getX() {  
    35.         return x;  
    36.     }  
    37.   
    38.   
    39.     public void setX(int x) {  
    40.         this.x = x;  
    41.     }  
    42.   
    43.   
    44.     public int getY() {  
    45.         return y;  
    46.     }  
    47.   
    48.   
    49.     public void setY(int y) {  
    50.         this.y = y;  
    51.     }  
    52.   
    53.   
    54.     @Override  
    55.     public int hashCode() {  
    56.         final int prime = 31;  
    57.         int result = 1;  
    58.         result = prime * result + x;  
    59.         result = prime * result + y;  
    60.         return result;  
    61.     }  
    62.   
    63.   
    64.     @Override  
    65.     public boolean equals(Object obj) {  
    66.         if (this == obj)  
    67.             return true;  
    68.         if (obj == null)  
    69.             return false;  
    70.         if (getClass() != obj.getClass())  
    71.             return false;  
    72.         Point other = (Point) obj;  
    73.         if (x != other.x)  
    74.             return false;  
    75.         if (y != other.y)  
    76.             return false;  
    77.         return true;  
    78.     }  
    79.   
    80.   
    81.     @Override  
    82.     public String toString() {  
    83.         return "x:" + x + ",y:" + y;  
    84.     }  
    85.   
    86. }  
    87. </span>  
     
    运行结果：
    [java] view plain copy
     
    1. <span style="font-size:18px;">x:1,y:1  
    2. x:10,y:10</span>  
     
    原因分析：
        假设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值的相关信息，否则会导致内存泄露问题。
  • 相关阅读:
    PS网页设计教程V——如何在Photoshop中创建一个商业网站布局
    PS网页设计教程IX——巧用大括号设计惊艳的咨询页面
    javascript笔记：拷贝出腾讯微博关于London2012奥运会的拉绳开关的网页特效
    备忘录（二）泛型详解（转载）
    把自己开发的网站前端开发框架和大家分享下
    大数据时代的技术hive：hive的数据类型和数据模型
    大数据时代的技术hive：hive介绍
    我设计的网站的分布式架构
    javascript及php笔记：自己动手写一个ajax异步上传文件的jquery插件
    javascript笔记：推荐使用“百度统计”并且拷贝百度统计的前端框架
  • 原文地址：https://www.cnblogs.com/111testing/p/8648159.html
Copyright © 2011-2022 走看看