hashset为什么要重写hashCode() 和 equals() 方法？以及重写时的代码解析？

object对象中的 public boolean equals(Object obj)，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true；
注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。如下：
(1)当obj1.equals(obj2)为true时，obj1.hashCode() == obj2.hashCode()必须为true
(2)当obj1.hashCode() == obj2.hashCode()为false时，obj1.equals(obj2)必须为false
如果不重写equals，那么比较的将是对象的引用是否指向同一块内存地址，重写之后目的是为了比较两个对象的value值是否相等。特别指出利用equals比较八大包装对象
（如int，float等）和String类（因为该类已重写了equals和hashcode方法）对象时，默认比较的是值，在比较其它自定义对象时都是比较的引用地址
hashcode是用于散列数据的快速存取，如利用HashSet/HashMap/Hashtable类来存储数据时，都是根据存储对象的hashcode值来进行判断是否相同的。
这样如果我们对一个对象重写了euqals，意思是只要对象的成员变量值都相等那么euqals就等于true，但不重写hashcode，那么我们再new一个新的对象，
当原对象.equals（新对象）等于true时，两者的hashcode却是不一样的，由此将产生了理解的不一致，如在存储散列集合时（如Set类），将会存储了两个值一样的对象，
导致混淆，因此，就也需要重写hashcode()

hashset判断集合中的元素是否唯一，是通过元素的两个方法，hashCode和equals方法来完成，如果元素的HashCode值相同，才会判断equals是否为true，如果元素的HashCode值不同，才会调用equals,复写这两个方法的代码解析如下：

1. public static int hashCode()  //这是复写hashcode方法，原本是通过hash算法得出不同的hash值，现在为了保证哈希地址值一致，统一返回一个数，可以是任意的
   
2.     {
   
3.          return 60;
   
4.      }
   
5.     public boolean equals(Object obj)  //这是复写equals方法，用传入person类作为参数作为一个例子
   
6.     {
   
7.          if(!(obj instanceof Person))  //先判断一下传进来的参数是否为Person类的对象，是的话才能判断
   
8.               return false;
   
9.          Person p = (Person)obj;  //多态的局限性，object类里并没有person的属性，需要强转为person类型
   
10.          return this.name.equals(p.name);  //比较一下字符串是否相同，并返回
    
11.      }

复制代码

1. 1、HashSet如何添加元素
   
2.          当向一个HashSet集合添加元素的时候，HashSet会调用对象的hashCode()方法来得到哈希值，然后根据HashCode值决定该对象在HashSet中的存储位置，如果
   
3. 
   
4.         对应哈希值的内存中没有元素，则添加成功；如果对应的哈希值得内存中有了元素，则调用对象的equals方法和内存中元素比较，如果一样，就不无法添加；
   
5. 
   
6.         如果不一样，则也能添加成功（只是在这个内存中，两个元素以链表的形式组织),当然如果相同的对象他们的哈希值不同，也能把元素添加进去
   
7. 
   
8. [java] view plaincopyprint?import java.util.*;  
   
9. import java.util.*;  
   
10. class A  
    
11. {  
    
12.     //模拟哈希值相同，对象元素相同情况   
    
13.     private String name;  
    
14.     A(String name){this.name=name;}  
    
15.     public int hashCode()  
    
16.     {  
    
17.         return name.hashCode();  
    
18.     }  
    
19.     public boolean equals(Object o)  
    
20.     {  
    
21.         A p=(A)o;  
    
22.        return p.name.equals(name);  
    
23.     }  
    
24.     public String toString()  
    
25.     {  
    
26.         return name;  
    
27.     }  
    
28. }  
    
29. class B  
    
30. {  
    
31.     //模拟哈希值相同，对象元素不同的情况   
    
32.     private String name;  
    
33.     B(String name){this.name=name;}  
    
34.     public int hashCode()  
    
35.     {  
    
36.         return 1;  
    
37.     }  
    
38.     public boolean equals(Object o)  
    
39.     {   
    
40.        B p=(B)o;  
    
41.        return false;  
    
42.     }  
    
43.     public String toString()  
    
44.     {  
    
45.         return name;  
    
46.     }  
    
47. }  
    
48. class C  
    
49. {  
    
50.     //模拟哈希值不同，但对象元素相同的情况   
    
51.     private String name;  
    
52.     boolean b=false;  
    
53.     C(String name){this.name=name;}  
    
54.     public int hashCode()  
    
55.     {  
    
56.         if(b==false)  
    
57.         {  
    
58.           b=true;  
    
59.           return 1;  
    
60.         }  
    
61.         else  
    
62.             return 3;  
    
63.     }  
    
64.     public boolean equals(Object o)  
    
65.     {  
    
66.         return true;  
    
67.     }  
    
68.     public String toString()  
    
69.     {  
    
70.         return name;  
    
71.     }  
    
72. }  
    
73. public class SetDemo  
    
74. {  
    
75.     public static void main(String[]agrs)  
    
76.     {  
    
77.          
    
78.         //哈希值相同，但元素相同无法插入无语   
    
79.         HashSet book1=new HashSet();  
    
80.         book1.add(new A("xiaocai"));  
    
81.         book1.add(new A("xiaocai"));  
    
82.         System.out.println(book1);  
    
83.         
    
84.         //当哈希值相同，但元素比较不同，仍可以插入集合   
    
85.         HashSet book2=new HashSet();  
    
86.         book2.add(new B("xiaocui"));  
    
87.         book2.add(new B("xiaocui"));  
    
88.         System.out.println(book2);  
    
89.   
    
90.         //虽然哈希值不同，当元素相同，仍然可以插入集合   
    
91.         HashSet book3=new HashSet();  
    
92.         book3.add(new B("xiaosun"));  
    
93.         book3.add(new B("xiaosun"));  
    
94.         System.out.println(book3);  
    
95.     }  
    
96. }  
    
97. import java.util.*;
    
98. import java.util.*;
    
99. class A
    
100. {
     
101.         //模拟哈希值相同，对象元素相同情况
     
102.         private String name;
     
103.         A(String name){this.name=name;}
     
104.     public int hashCode()
     
105.         {
     
106.                 return name.hashCode();
     
107.         }
     
108.         public boolean equals(Object o)
     
109.         {
     
110.         A p=(A)o;
     
111.            return p.name.equals(name);
     
112.         }
     
113.         public String toString()
     
114.         {
     
115.         return name;
     
116.         }
     
117. }
     
118. class B
     
119. {
     
120.         //模拟哈希值相同，对象元素不同的情况
     
121.         private String name;
     
122.         B(String name){this.name=name;}
     
123.     public int hashCode()
     
124.         {
     
125.                 return 1;
     
126.         }
     
127.         public boolean equals(Object o)
     
128.         {  
     
129.        B p=(B)o;
     
130.            return false;
     
131.         }
     
132.     public String toString()
     
133.         {
     
134.         return name;
     
135.         }
     
136. }
     
137. class C
     
138. {
     
139.         //模拟哈希值不同，但对象元素相同的情况
     
140.         private String name;
     
141.         boolean b=false;
     
142.         C(String name){this.name=name;}
     
143.         public int hashCode()
     
144.         {
     
145.                 if(b==false)
     
146.                 {
     
147.                   b=true;
     
148.                   return 1;
     
149.                 }
     
150.                 else
     
151.                         return 3;
     
152.         }
     
153.         public boolean equals(Object o)
     
154.         {
     
155.                 return true;
     
156.         }
     
157.     public String toString()
     
158.         {
     
159.         return name;
     
160.         }
     
161. }
     
162. public class SetDemo
     
163. {
     
164.         public static void main(String[]agrs)
     
165.         {
     
166.                
     
167.                 //哈希值相同，但元素相同无法插入无语
     
168.         HashSet book1=new HashSet();
     
169.         book1.add(new A("xiaocai"));
     
170.         book1.add(new A("xiaocai"));
     
171.                 System.out.println(book1);
     
172.       
     
173.                 //当哈希值相同，但元素比较不同，仍可以插入集合
     
174.                 HashSet book2=new HashSet();
     
175.         book2.add(new B("xiaocui"));
     
176.         book2.add(new B("xiaocui"));
     
177.                 System.out.println(book2);
     
178. 
     
179.                 //虽然哈希值不同，当元素相同，仍然可以插入集合
     
180.         HashSet book3=new HashSet();
     
181.         book3.add(new B("xiaosun"));
     
182.         book3.add(new B("xiaosun"));
     
183.                 System.out.println(book3);
     
184.         }
     
185. }   当然我们更希望的是HashSet集合中的每个对应的哈希值中只存放一个元素，因此我们就必须正确重写对象的hashCode和equals方法，通常我们尽量保证两个对象通过equals()方法比较返回true时，他们的hashCode()方法返回值也相等      
     
186. 
     

复制代码