JAVA中重写equals()方法为什么要重写hashcode()方法说明

重写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 的人员信息:【姓名】：张山