java中equals方法和hashcode方法的区别和联系，以及为何要重写这两个方法，不重写会怎样

时间  2019-11-13
标签 java equals 方法 hashcode 区别 联系 以及 为何 重写 两个 怎样 栏目 Java 繁體版
原文   原文链接 
1、在Object类中的定义为:
public native int hashCode();
是一个本地方法，返回的对象的地址值。
可是，一样的思路，在String等封装类中对此方法进行了重写。方法调用获得一个计算公式获得的 int值。

2、在重写任何类得hashcode方法时必须遵循如下几点：
一、在Java应用的同一次执行过程当中，同一对象被屡次调用，则他们的hashcode值必然相同。
而对于同一个应用的两次不一样的调用，它们的Hashcode值能够相同，也有可能不一样。
二、对于两个对象来讲，若是他们的equals方法比较返回true，那么这两个对象的hashcode必然相同。
这也解释了为何String类中，若是两个对象的equals方法相同，则他们的hashcode值必定相同。
三、对于两个对象来讲，若是使用equals方法返回为false，则他们的hashcode的值有可能相等也可能不等，
（若是不一样会提升性能，由于在集合中类判断两个对象是否相等，若是其hashcode不等就直接不用判断equals方法了）
四、对于Object对象来讲，不一样的Object对象的hashcode是不一样的，它们返回的是对象的地址，
equals返回的也是对象的地址。因此在本身定义的类中若是要添加到集合对象中，
最好是要重写hashcode和equals方法，否则会自动继承自Object类中的两个方法根据对象地址来判断。
在重写本身定义的类时，一般是在类中的根据某个值如name.hashcode();来进行判断。

3、以HashSet 为例：
当咱们使用HashSet时，hashCode()方法就会被获得调用，判断已经存储在集合中的对象的hashCode值是否与所增长。
对象的hashCode值一致，若是“不一致”则直接加进去（不用比较equals()提升效率），若是一致，则进行equals方法的比较，若是返回true，代表集合里面已经有这个对象，不能添加进去了。若是是false表是集合里面没有这个对象，则能够加进去。因此在重写hashcode()或者equals() 方法的任何一个方法时，必须重写另一个。 
示例代码：
/** 
* People 手工重写hashcode方法和equals方法 根据name来判断 两个对象是否相等。 
*/ 
class People { 
private String name; 
public People(String name) { 
this.name = name; 
} 
@Override 
public boolean equals(Object obj) { 
//若是是本身 
if(this==obj){ 
return true ; 
} 
//若是是空 
if(obj==null ){ 
return false; 
} 
//比较两个People的名字是否相同 
if(obj!=null && obj instanceof People){ 
if(((People)obj).name.equals(this.name)) 
return true ; 
} 
return false; 
} 
@Override 
public int hashCode() { 
// String的hashcode原本就是用来比较两个字符是否相等 
return name.hashCode(); 
} 
}

从Object类的hashCode()和equals()方法讲起：   

 

      最近看了Object类的源码，对hashCode() 和equals()方法有了更深的认识。重写equals()方法就必须重写hashCode()方法的缘由，从源头Object类讲起就更好理解了。java
 

 

先来看Object关于hashCode()和equals()的源码：程序员
 

 

 
 

 

 
 
 
  
 
   [java]  
   view plain 
    copy 
   

       
   
 
  
 
 
 
 
     
  
  1. public native int hashCode();  
    2.  
 
 

 

 

 
 
 
  
 
   [java]  
   view plain 
    copy 
   

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

 

     光从代码中咱们能够知道，hashCode()方法是一个本地native方法，返回的是对象引用中存储的对象的内存地址，而equals方法是利用==来比较的也是对象的内存地址。从上边咱们能够看出，hashCode方法和equals方法是一致的。还有最关键的一点，咱们来看Object类中关于hashCode()方法的注释：
 

 
 

 

 
 

 

 
 
 
  
 
   [java]  
   view plain 
    copy 
   

       
   
 
  
 
 
 
 
     
  
  1. /** 
    2.  
  
  2.      * Returns a hash code value for the object. This method is 
    3.  
  
  3.      * supported for the benefit of hash tables such as those provided by 
    4.  
  
  4.      * {@link java.util.HashMap}. 
    5.  
  
  5.      * <p> 
    6.  
  
  6.      * The general contract of {@code hashCode} is: 
    7.  
  
  7.      * <ul> 
    8.  
  
  8.      * <li>Whenever it is invoked on the same object more than once during 
    9.  
  
  9.      *     an execution of a Java application, the {@code hashCode} method 
    10.  
  
  10.      *     must consistently return the same integer, provided no information 
    11.  
  
  11.      *     used in {@code equals} comparisons on the object is modified. 
    12.  
  
  12.      *     This integer need not remain consistent from one execution of an 
    13.  
  
  13.      *     application to another execution of the same application. 
    14.  
  
  14.      * <li>If two objects are equal according to the {@code equals(Object)} 
    15.  
  
  15.      *     method, then calling the {@code hashCode} method on each of 
    16.  
  
  16.      *     the two objects must produce the same integer result. 
    17.  
  
  17.      * <li>It is <em>not</em> required that if two objects are unequal 
    18.  
  
  18.      *     according to the {@link java.lang.Object#equals(java.lang.Object)} 
    19.  
  
  19.      *     method, then calling the {@code hashCode} method on each of the 
    20.  
  
  20.      *     two objects must produce distinct integer results.  However, the 
    21.  
  
  21.      *     programmer should be aware that producing distinct integer results 
    22.  
  
  22.      *     for unequal objects may improve the performance of hash tables. 
    23.  
  
  23.      * </ul> 
    24.  
  
  24.      * <p> 
    25.  
  
  25.      * As much as is reasonably practical, the hashCode method defined by 
    26.  
  
  26.      * class {@code Object} does return distinct integers for distinct 
    27.  
  
  27.      * objects. (This is typically implemented by converting the internal 
    28.  
  
  28.      * address of the object into an integer, but this implementation 
    29.  
  
  29.      * technique is not required by the 
    30.  
  
  30.      * Java™ programming language.) 
    31.  
  
  31.      * 
    32.  
  
  32.      * @return  a hash code value for this object. 
    33.  
  
  33.      * @see     java.lang.Object#equals(java.lang.Object) 
    34.  
  
  34.      * @see     java.lang.System#identityHashCode 
    35.  
  
  35.      */  
    36.  
  
  36.     public native int hashCode();  
    37.  
 
 

 

    简单的翻译一下就是，hashCode方法通常的规定是：
 

 
 

 

 
 

 

 
 
 
  
 
   [java]  
   view plain 
    copy 
   

       
   
 
  
 
 
 
 
     
  
  1. 1.在 Java 应用程序执行期间，在对同一对象屡次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另外一次执行，该整数无需保持一致。      
    2.  
  
  2. 2.若是根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每一个对象调用 hashCode 方法都必须生成相同的整数结果。      
    3.  
  
  3. 3.若是根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不 要求必定生成不一样的整数结果。可是，程序员应该意识到，为不相等的对象生成不一样整数结果能够提升哈希表的性能。  
    4.  
 
 

 

 

 
 

 

     再简单的翻译一下第二三点就是：hashCode()和equals()保持一致，若是equals方法返回true，那么两个对象的hasCode()返回值必须同样。若是equals方法返回false，hashcode能够不同，可是这样不利于哈希表的性能，通常咱们也不要这样作。重写equals()方法就必须重写hashCode()方法的缘由也就显而易见了。数组
 

 

   假设两个对象，重写了其equals方法，其相等条件是属性相等，就返回true。若是不重写hashcode方法，其返回的依然是两个对象的内存地址值，必然不相等。这就出现了equals方法相等，可是hashcode不相等的状况。这不符合hashcode的规则。下边，会介绍在集合框架中，这种状况会致使的严重问题。app
 

 

    重写的做用：
 

 


          若是重写（用于需求，好比创建一个Person类，比较相等我只比较其属性身份证相等就可无论其余属性，这时候重写）equals，就得重写hashCode，和其对象相等保持一致。若是不重写，那么调用的Object中的方法必定保持一致。 

 

 


         1.  重写equals()方法就必须重写hashCode()方法主要是针对HashSet和Map集合类型。集合框架只能存入对象（对象的引用（基本类型数据：自动装箱））。 

 

 


          在向HashSet集合中存入一个元素时，HashSet会调用该对象（存入对象）的hashCode()方法来获得该对象的hashCode()值，而后根据该hashCode值决定该对象在HashSet中存储的位置。简单的说：HashSet集合判断两个元素相等的标准是：两个对象经过equals()方法比较相等，而且两个对象的HashCode()方法返回值也相等。若是两个元素经过equals()方法比较返回true，可是它们的hashCode()方法返回值不一样，HashSet会把它们存储在不一样的位置，依然能够添加成功。一样：在Map集合中，例如其子类Hashtable（jdk1.0错误的命名规范），HashMap，存储的数据是<key,value>对，key，value都是对象，被封装在Map.Entry，即：每一个集合元素都是Map.Entry对象。在Map集合中，判断key相等标准也是：两个key经过equals()方法比较返回true，两个key的hashCode的值也必须相等。判断valude是否相等equal()相等便可。 

 

 


        稍微提一句：（1）两个对象，用==比较比较的是地址，需采用equals方法（可根据需求重写）比较。 

 

 


                                （2）重写equals()方法就重写hashCode()方法。 

 

 


                                 （3）通常相等的对象都规定有相同的hashCode。 

 

 


                                  hash：散列，Map关联数组，字典 

 

 


       2. 集合类都重写了toString方法。String类重写了equal和hashCode方法，比较的是值。 

 

 

     用HashSet来验证两个需都重写的必要性
 

 


        程序提供了三个类A,B,C，它们分别重写了equals()，hashCode()两个方法中的一个或所有。 

 

 
 
 
  
class A {
String certificate;框架
 
  
public A(String certificate) {ide
 
  
this.certificate = certificate;
}性能
 
  
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
A other = (A) obj;
if (certificate == null) {
if (other.certificate != null)
return false;
} else if (!certificate.equals(other.certificate))
return false;
return true;
}ui
 
  
}this
 
  
class B {
String certificate;// 身份证号spa
 
  
public B(String certificate) {
 
  
this.certificate = certificate;
}
 
  
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((certificate == null) ? 0 : certificate.hashCode());
return result;
}
}
 
  
class C {
String certificate;
 
  
public C(String certificate) {
 
  
this.certificate = certificate;
}
 
  
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((certificate == null) ? 0 : certificate.hashCode());
return result;
}
 
  
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
C other = (C) obj;
if (certificate == null) {
if (other.certificate != null)
return false;
} else if (!certificate.equals(other.certificate))
return false;
return true;
}
 
  
}
 
  
 
 
 
 

 

 

 
 
 
  
 
   

       
   
 
  
 
 
 

 

 
 
 
  
 
   

       
    
 
     
package day02;
 
     
import java.util.HashSet;
 
     
public class EqualsHashcodeDemo {
public static void main(String[] args) {

HashSet<A> hashSetA = new HashSet();
hashSetA.add(new A("123"));
hashSetA.add(new A("123"));
for (Object hs : hashSetA) { 
System.out.println(hs); 
} 


HashSet<B> hashSetB = new HashSet<B>();
hashSetB.add(new B("345"));
hashSetB.add(new B("345"));
for (Object hs : hashSetB) { 
System.out.println(hs); 
}
HashSet<C> hashSetC = new HashSet<C>();
hashSetC.add(new C("456"));
hashSetC.add(new C("456"));
for (Object hs : hashSetC) { 
System.out.println(hs); 
}
/**
* public int hashCode() { int h = hash; if (h == 0 && value.length > 0) { char
* val[] = value;
* 
* for (int i = 0; i < value.length; i++) { h = 31 * h + val[i]; } hash = h; }
* return h; }
*/
 
     
}
}
 
     
 
 
     

       其结果为： 
     
 
     
 
     
 
     
 
     
 
      
 
       
 
        
 
         [java]  
         view plain 
          copy 
         

             
         
 
        
 
       
 
       
cn.edu.uestc.collection.B@1  
 
       
day02.A@15db9742
 
       
day02.A@6d06d69c  //第一个set(hashSetA)中居然把同一个元素放入了set中，两次，且算出的hashcode值也不一致，这就说明将同一元素放到了同一个set的不一样位置,里面有两个，一个set中的不一样位置放了两个相同的A；
 
       
day02.B@c613
 
       
day02.B@c613    //第二个set(hashSetB)也把同一个元素放入了set中，两次，算出的hashcode值一致，这就说明将同一元素放到了同一个set的相同位置，放了两次而已, 同一个set的相同位置放了两个相同的B；
 
       
day02.C@c9f4  //第三个set(hashSetC)也把同一个元素放入了set中，两次，可是set中只保存了一个C，说明只有重写两个方法，才能达到结果；
 
      
     从上边的程序结果能够看到，必需要同时重写这两个方法，要否则Set的特性就被破坏了。 
     
 
     
 
 
     
 
      
 
       
 
        

            
        
 
       
 
      
 
     
 
    
 
   
 
  
 
 
 

 


    

 

 

     重写hashCode()的原则
 

 


      （1）同一个对象屡次调用hashCode()方法应该返回相同的值； 

 

 


      （2）当两个对象经过equals()方法比较返回true时，这两个对象的hashCode()应该返回相等的（int）值； 

 

 


      （3）对象中用做equals()方法比较标准的Filed(成员变量（类属性）)，都应该用来计算hashCode值。 

 

 


        计算hashCode值的方法：       

 

 

 
 
 
  
 
   
 
    [java]  
    view plain 
     copy 
    

        
    
 
   
 
  
 
  
     
   
  1. //f是Filed属性  
    2.  
   
  2. boolean    hashCode=(f?0:1)  
    3.  
   
  3. (byte,short,char,int)      hashCode=(int)f  
    4.  
   
  4. long       hashCode=(int)(f^(f>>>32))  
    5.  
   
  5. float       hashCode=Float.floatToIntBits(f)  
    6.  
   
  6. double   hashCode=(int)(1^(1>>>32))  
    7.  
   
  7. 普通引用类型    hashCode=f.hashCode()  
    8.  
  
 
 
        将计算出的每一个Filed的hashCode值相加返回，为了不直接相加产生的偶然相等（单个不相等，加起来就相等了），为每一个Filed乘以一个质数后再相加，例若有： 

 

 

 
 
 
  
 
   
 
    [java]  
    view plain 
     copy 
    

        
    
 
   
 
  
 
  
     
   
  1. return  f1.hashCode()*17+(int)f2.13  
    2.  
  
 
 
       

 

 


      查看String源码，看hashCode()d的实现方法： 

 

 


    

 

 


    

 

 

 
 
 
  
 
   
 
    [java]  
    view plain 
     copy 
    

        
    
 
   
 
  
 
  
     
   
  1. /** 
    2.  
   
  2.    * Returns a hash code for this string. The hash code for a 
    3.  
   
  3.    * <code>String</code> object is computed as 
    4.  
   
  4.    * <blockquote><pre> 
    5.  
   
  5.    * s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] 
    6.  
   
  6.    * </pre></blockquote> 
    7.  
   
  7.    * using <code>int</code> arithmetic, where <code>s[i]</code> is the 
    8.  
   
  8.    * <i>i</i>th character of the string, <code>n</code> is the length of 
    9.  
   
  9.    * the string, and <code>^</code> indicates exponentiation. 
    10.  
   
  10.    * (The hash value of the empty string is zero.) 
    11.  
   
  11.    * 
    12.  
   
  12.    * @return  a hash code value for this object. 
    13.  
   
  13.    */  
    14.  
   
  14.   public int hashCode() {  
    15.  
   
  15.       int h = hash;  
    16.  
   
  16.       if (h == 0 && value.length > 0) {  
    17.  
   
  17.           char val[] = value;  
    18.  
   
  18.   
    19.  
   
  19.           for (int i = 0; i < value.length; i++) {  
    20.  
   
  20.               h = 31 * h + val[i];  
    21.  
   
  21.           }  
    22.  
   
  22.           hash = h;  
    23.  
   
  23.       }  
    24.  
   
  24.       return h;  
    25.  
   
  25.   }  
    26.  
   
  26.  
  
 
 
 

 

 
 

 
 
 
  
 
   
 
    
 
     
 
      
 
       
 
        [java]  
        view plain 
         copy 
        

            
        
 
       
 
      
 
      
     
       
  1. public class A {  
    2.  
       
  2.     @Override  
    3.  
       
  3.     public boolean equals(Object obj) {  
    4.  
       
  4.         return true;  
    5.  
       
  5.     }  
    6.  
       
  6. }  
    7.  
      
 
     
 
     
 
     
 
      
 
       
 
        [java]  
        view plain 
         copy 
        

            
        
 
       
 
      
 
      
     
       
  1. public class B {  
    2.  
       
  2.     @Override  
    3.  
       
  3.     public int hashCode() {  
    4.  
       
  4.         return 1;  
    5.  
       
  5.     }  
    6.  
       
  6. }  
    7.  
      
 
     
 
     
 
     
 
      
 
       
 
        [java]  
        view plain 
         copy 
        

            
        
 
       
 
      
 
      
     
       
  1. public class C {  
    2.  
       
  2.     @Override  
    3.  
       
  3.     public int hashCode() {  
    4.  
       
  4.         return 2;  
    5.  
       
  5.     }  
    6.  
       
  6.   
    7.  
       
  7.     @Override  
    8.  
       
  8.     public boolean equals(Object obj) {  
    9.  
       
  9.         return true;  
    10.  
       
  10.     }  
    11.  
       
  11. }  
    12.  
      
 
     
 
    
 
    
 
    
 
     
 
      
 
       
 
        [java]  
        view plain 
         copy 
       
 
      
 
     
 
    
 
   
 
  
 
  
     
   
  1. public class HashSetTest {  
    2.  
   
  2.     public static void main(String[] args) {  
    3.  
   
  3.         HashSet hashSet = new HashSet();  
    4.  
   
  4.         hashSet.add(new A());  
    5.  
   
  5.         hashSet.add(new A());  
    6.  
   
  6.         hashSet.add(new B());  
    7.  
   
  7.         hashSet.add(new B());  
    8.  
   
  8.         hashSet.add(new C());  
    9.  
   
  9.         hashSet.add(new C());  
    10.  
   
  10.         for (Object hs : hashSet) {  
    11.  
   
  11.             System.out.println(hs);  
    12.  
   
  12.         }  
    13.  
   
  13.         //HashSet重写了toString()方法  
    14.  
   
  14. //        System.out.println(hashSet);  
    15.  
   
  15.     }  
    16.  
   
  16. }  
    17.  
  
 
 
      其结果为： 

 

 

 

 

 
 
 
  
 
   
 
    [java]  
    view plain 
     copy 
    

        
    
 
   
 
  
 
  
     
   
  1. cn.edu.uestc.collection.B@1  
    2.  
   
  2. cn.edu.uestc.collection.B@1  
    3.  
   
  3. cn.edu.uestc.collection.C@2  
    4.  
   
  4. cn.edu.uestc.collection.A@3f84246a  
    5.  
   
  5. cn.edu.uestc.collection.A@18a9fa9c  
    6.  
   
  6. Process finished with exit code 0  
    7.  
  
 
 
     从上边的程序结果能够看到，必需要同时重写这两个方法，要否则Set的特性就被破坏了。 



        

            

        	





    

		

            
相关文章

            

                

                

                    

                

            


            
相关标签/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公众号
    

    

           欢迎关注本站公众号,获取更多信息

        
    




    

    




	


	







    

        联系我们
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程