为什么重写equals方法,一定要重写HashCode方法?


(2013-04-01 15:24:30)
标签:

杂谈

分类: 面试笔试
主要原因是默认从Object继承来的hashCode是基于对象的ID实现的。
如果你重载了equals,比如说是基于对象的内容实现的,而保留hashCode的实现不变,那么很可能某两个对象明明是“相等”,而hashCode却不一样。
这样,当你用其中的一个作为键保存到hashMap、hasoTable或hashSet中,再以“相等的”找另一个作为键值去查找他们的时候,则根本找不到。

使用HashMap,如果key是自定义的类,就必须重写hashcode()和equals()。

     1.hashcode()和equals()是在哪里被用到的?什么用的?

      HashMap是基于散列函数,以数组和链表的方式实现的。

 而对于每一个对象,通过其hashCode()方法可为其生成一个整形值(散列码),该整型值被处理后,将会作为数组下标,存放该对象所对应的Entry(存放该对象及其对应值)。

 equals()方法则是在HashMap中插入值或查询时会使用到。当HashMap中插入值或查询值对应的散列码与数组中的散列码相等时,则会通过equals方法比较key值是否相等,所以想以自建对象作为HashMap的key,必须重写该对象继承object的hashCode和equals方法。

    
     2.本来不就有hashcode()和equals()了么?干嘛要重写,直接用原来的不行么?
         
          HashMap中,如果要比较key是否相等,要同时使用这两个函数!因为自定义的类的hashcode()方法继承于Object类,其hashcode码为默认的内存地址,这样即便有相同含义的两个对象,比较也是不相等的,例如,生成了两个“羊”对象,正常理解这两个对象应该是相等的,但如果你不重写 hashcode()方法的话,比较是不相等的!
          HashMap中的比较key是这样的,先求出key的hashcode(),比较其值是否相等,若相等再比较equals(),若相等则认为他们是相等的。若equals()不相等则认为他们不相等。如果只重写hashcode()不重写equals()方法,当比较equals()时只是看他们是否为同一对象(即进行内存地址的比较),所以必定要两个方法一起重写。HashMap用来判断key是否相等的方法,其实是调用了HashSet判断加入元素是否相等。
 

引用别人说的一段话哈~
一般来说,如果你要把一个类的对象放入容器中,那么通常要为其重写equals()方法,让他们比较地址值而不是内容值。特别地,如果要把你的类的对象放入散列中,那么还要重写hashCode()方法;要放到有序容器中,还要重写compareTo()方法。
equals()相等的两个对象,hashcode()一定相等;
equals()不相等的两个对象,却并不能证明他们的hashcode()不相等。换句话说,equals()方法不相等的两个对象,hashcode()有可能相等。(我的理解是由于哈希码在生成的时候产生冲突造成的)。
反过来:hashcode()不等,一定能推出equals()也不等;hashcode()相等,equals()可能相等,也可能不等

我的理解哈,
不同的key有可能是一样的code,所以需要再用equals来处理hash冲突,其实只要拿个equals也行,但是效率会降低
在list对象中也存在同样的问题,也需要重写equals方法
这些都是我的老师告诉我的,其实我在用arraylist的时候存储的比较简单,但是老师让我加一些附加信息,不重写的话,比较的是内存地址,那么如果你不断的new,它会认为是相同的



重写hashCode()时最重要的原因就是:无论何时,对同一个对象调用hashCode()都应该生成同样的值。如果在将一个对象用put()方法添加进HashMap时产生一个hashCode()值,而用get()取出时却产生了另外一个 hashCode()值,那么就无法重新取得该对象了。所以,如果你的hashCode()方法依赖于对象中易变的数据,那用户就要小心了,因为此数据发生变化时,hashCode()就会产生一个不同的hash码,相当于产生了一个不同的“键”。 

      Object的hashCode()方法,返回的是当前对象的内存地址。下次如果我们需要取一个一样的“键”对应的键值对的时候,我们就无法得到一样的hashCode值了。因为我们后来创建的“键”对象已经不是存入HashMap中的那个内存地址的对象了。 

      我们看一个简单的例子,就能更加清楚的理解上面的意思。假定我们写了一个类:Person (人),我们判断一个对象“人”是否指向同一个人,只要知道这个人的身份证号一直就可以了。 

      先来个没有重写Code类的hashcode()的例子吧,看看是什么效果:

Java代码   收藏代码
  1. package com.fit;  
  2.   
  3. import java.util.HashMap;  
  4.   
  5. /** 
  6.  * 身份证类 
  7.  *  
  8.  * @author ZYD 
  9.  *  
  10.  */  
  11. public class Code {  
  12.   
  13.     /** 
  14.      * 身份证号码,一旦确定就不能更改 
  15.      */  
  16.     private final int id;  
  17.   
  18.     public int getId() {  
  19.         return id;  
  20.     }  
  21.   
  22.     /** 
  23.      * 通过构造方法确定身份证号码 
  24.      *  
  25.      * @param id 
  26.      */  
  27.     public Code(int id) {  
  28.         this.id = id;  
  29.     }  
  30.   
  31.     /** 
  32.      * 重写equals()方法 
  33.      */  
  34.     public boolean equals(Object o) {  
  35.         // 如果地址一样,则两个对象相同  
  36.         if (this == o) {  
  37.             return true;  
  38.         }  
  39.         // 如果两个对象是同一类型,则比较其属性值是否都相同。如果都相同,则说明两个对象也相同;否则,说明这两个对象不相同。  
  40.         if (o instanceof Code) {  
  41.             Code co = (Code) o;  
  42.             boolean b = (co.id == this.id);  
  43.             return b;  
  44.         }  
  45.         return false;  
  46.     }  
  47.   
  48.     /** 
  49.      * 重写toString()方法 
  50.      */  
  51.     public String toString() {  
  52.         return "【身份证】:" + id;  
  53.     }  
  54.       
  55.     /** 
  56.      * 测试 
  57.      * @param args 
  58.      */  
  59.     public static void main(String[] args) {  
  60.           
  61.          HashMap<Code, Person> map = new HashMap<Code, Person>();  
  62.            
  63.          Person p1 = new Person(new Code(10001),"张三");  
  64.          Person p2 = new Person(new Code(10002),"李四");  
  65.            
  66.          map.put(p1.getCode(), p1);  
  67.          map.put(p2.getCode(), p2);  
  68.            
  69.          System.out.println("HashMap 中存放的人员信息:\n"+map);  
  70.            
  71.          //张三改名为张山,身份证号不变。  
  72.          Person p3 = new Person(new Code(10001),"张山");  
  73.          map.put(p3.getCode(), p3);  
  74.            
  75.          System.out.println("张三改名为张山后 HashMap 中存放的人员信息:\n"+map);  
  76.            
  77.          //查找身份证为10001 的人员信息  
  78.          System.out.println("查找身份证为:10001 的人员信息:"+map.get(new Code(10001)));  
  79.     }  
  80. }  
  81.   
  82. /** 
  83.  * 人类 
  84.  * @author Administrator 
  85.  * 
  86.  */  
  87. class Person {  
  88.   
  89.     /** 
  90.      * 每一个成人都有一个身份证 
  91.      */  
  92.     private Code code;  
  93.   
  94.     /** 
  95.      * 姓名 
  96.      */  
  97.     private String name;  
  98.   
  99.     public Code getCode() {  
  100.         return code;  
  101.     }  
  102.   
  103.     public void setCode(Code code) {  
  104.         this.code = code;  
  105.     }  
  106.   
  107.     public String getName() {  
  108.         return name;  
  109.     }  
  110.   
  111.     public void setName(String name) {  
  112.         this.name = name;  
  113.     }  
  114.   
  115.     public Person() {  
  116.   
  117.     }  
  118.   
  119.     public Person(Code code, String name) {  
  120.         this.code = code;  
  121.         this.name = name;  
  122.     }  
  123.   
  124.     /** 
  125.      * 重写equals()方法 当两个人得身份证号相同以及姓名相同时,表示这两个人是同一个人。 
  126.      */  
  127.     public boolean equals(Object o) {  
  128.         if (o == this) {  
  129.             return true;  
  130.         }  
  131.         if (o instanceof Person) {  
  132.             Person p = (Person) o;  
  133.             boolean b = this.code.equals(p.code) && this.name.equals(p.name);  
  134.             return b;  
  135.         }  
  136.         return false;  
  137.     }  
  138.   
  139.     /** 
  140.      * 重写toString()方法 
  141.      */  
  142.     public String toString() {  
  143.         return "【姓名】:" + name + "  ";  
  144.     }  
  145. }  

 

 

运行结果:

 

HashMap 中存放的人员信息:
{【身份证】:10002=【姓名】:李四  , 【身份证】:10001=【姓名】:张三  }
张三改名为张山后 HashMap 中存放的人员信息:
{【身份证】:10002=【姓名】:李四  , 【身份证】:10001=【姓名】:张三  , 【身份证】:10001=【姓名】:张山  }
查找身份证为:10001 的人员信息:null

 

从上面的结果可以看出:

我们所做的更新和查找操作都失败了。失败的原因就是我们的身份证类:Code 没有覆写hashCode()方法。这个时候,当查找一样的身份证号码的键值对的时候,使用的是默认的对象的内存地址来进行定位。这样,后面的所有的身份证号对象

new Code(10001) 产生的hashCode()值都是不一样的,所以导致操作失败。

 

 

 重写Code类的hashcode(),代码上:

 

Java代码   收藏代码
  1. package com.fit;  
  2.   
  3. import java.util.HashMap;  
  4.   
  5. /** 
  6.  * 身份证类 
  7.  *  
  8.  * @author ZYD 
  9.  *  
  10.  */  
  11. public class Code {  
  12.   
  13.     /** 
  14.      * 身份证号码,一旦确定就不能更改 
  15.      */  
  16.     private final int id;  
  17.   
  18.     public int getId() {  
  19.         return id;  
  20.     }  
  21.   
  22.     /** 
  23.      * 通过构造方法确定身份证号码 
  24.      *  
  25.      * @param id 
  26.      */  
  27.     public Code(int id) {  
  28.         this.id = id;  
  29.     }  
  30.   
  31.     /** 
  32.      * 重写equals()方法 
  33.      */  
  34.     public boolean equals(Object o) {  
  35.         // 如果地址一样,则两个对象相同  
  36.         if (this == o) {  
  37.             return true;  
  38.         }  
  39.         // 如果两个对象是同一类型,则比较其属性值是否都相同。如果都相同,则说明两个对象也相同;否则,说明这两个对象不相同。  
  40.         if (o instanceof Code) {  
  41.             Code co = (Code) o;  
  42.             boolean b = (co.id == this.id);  
  43.             return b;  
  44.         }  
  45.         return false;  
  46.     }  
  47.   
  48.     /** 
  49.      * 重写hashcode()方法,以身份证号码作为hash码。 
  50.      *  
  51.      * @return 
  52.      */  
  53.     public int hashCode() {  
  54.         return id;  
  55.     }  
  56.   
  57.     /** 
  58.      * 重写toString()方法 
  59.      */  
  60.     public String toString() {  
  61.         return "【身份证】:" + id;  
  62.     }  
  63.       
  64.     /** 
  65.      * 测试 
  66.      * @param args 
  67.      */  
  68.     public static void main(String[] args) {  
  69.           
  70.          HashMap<Code, Person> map = new HashMap<Code, Person>();  
  71.            
  72.          Person p1 = new Person(new Code(10001),"张三");  
  73.          Person p2 = new Person(new Code(10002),"李四");  
  74.            
  75.          map.put(p1.getCode(), p1);  
  76.          map.put(p2.getCode(), p2);  
  77.            
  78.          System.out.println("HashMap 中存放的人员信息:\n"+map);  
  79.            
  80.          //张三改名为张山,身份证号不变。  
  81.          Person p3 = new Person(new Code(10001),"张山");  
  82.          map.put(p3.getCode(), p3);  
  83.            
  84.          System.out.println("张三改名为张山后 HashMap 中存放的人员信息:\n"+map);  
  85.            
  86.          //查找身份证为10001 的人员信息  
  87.          System.out.println("查找身份证为:10001 的人员信息:"+map.get(new Code(10001)));  
  88.     }  
  89. }  
  90.   
  91. /** 
  92.  * 人类 
  93.  * @author Administrator 
  94.  * 
  95.  */  
  96. class Person {  
  97.   
  98.     /** 
  99.      * 每一个成人都有一个身份证 
  100.      */  
  101.     private Code code;  
  102.   
  103.     /** 
  104.      * 姓名 
  105.      */  
  106.     private String name;  
  107.   
  108.     public Code getCode() {  
  109.         return code;  
  110.     }  
  111.   
  112.     public void setCode(Code code) {  
  113.         this.code = code;  
  114.     }  
  115.   
  116.     public String getName() {  
  117.         return name;  
  118.     }  
  119.   
  120.     public void setName(String name) {  
  121.         this.name = name;  
  122.     }  
  123.   
  124.     public Person() {  
  125.   
  126.     }  
  127.   
  128.     public Person(Code code, String name) {  
  129.         this.code = code;  
  130.         this.name = name;  
  131.     }  
  132.   
  133.     /** 
  134.      * 重写equals()方法 当两个人得身份证号相同以及姓名相同时,表示这两个人是同一个人。 
  135.      */  
  136.     public boolean equals(Object o) {  
  137.         if (o == this) {  
  138.             return true;  
  139.         }  
  140.         if (o instanceof Person) {  
  141.             Person p = (Person) o;  
  142.             boolean b = this.code.equals(p.code) && this.name.equals(p.name);  
  143.             return b;  
  144.         }  
  145.         return false;  
  146.     }  
  147.   
  148.     /** 
  149.      * 重写toString()方法 
  150.      */  
  151.     public String toString() {  
  152.         return "【姓名】:" + name + "  ";  
  153.     }  
  154. }  

 

 

运行效果:

 

HashMap 中存放的人员信息:
{【身份证】:10001=【姓名】:张三  , 【身份证】:10002=【姓名】:李四  }
张三改名为张山后 HashMap 中存放的人员信息:
{【身份证】:10001=【姓名】:张山  , 【身份证】:10002=【姓名】:李四  }
查找身份证为:10001 的人员信息:【姓名】:张山 

 


  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值