HashSet中的判断和删除的依据是先比较hashcode，如果不一样再比较equals方法，可是我找不到方法证明这个结论？求助啊

1. package com.itcast.practise;
   
2. 
   
3. import java.util.*;
   
4. class PersonPractise{
   
5.         private String name;
   
6.         private int age;
   
7.         PersonPractise(String name,int age){
   
8.                 this.name = name;
   
9.                 this.age = age;
   
10.                  
    
11.         }
    
12.         public String getName(){
    
13.                 return name;
    
14.         }
    
15.         public int getAge(){
    
16.                 return age;
    
17.         }
    
18.         public void setName(String name){
    
19.                 this.name = name;
    
20.                
    
21.         }
    
22.         public void setAge(int age){
    
23.                 this.age = age;
    
24.                
    
25.         }
    
26.         //如果把hashCode方法注释掉可以看出如果对象不同，hashCode就不一样，只比较了hashCode没调用equals方法
    
27.         //如果把hashCode方法不注释掉并且让它返回一个整数。那么PersonPractise的每个实例对象的hashCode都一样，
    
28.         //根据结果显示，使用HashSet的add方法时调用了equals方法。
    
29.         public int hashCode(){
    
30.                 return 100;
    
31.                
    
32.         }
    
33.         public boolean equals(Object obj){
    
34.                 PersonPractise p =(PersonPractise)obj;
    
35.                 //打印是怎么比较的
    
36.                 System.out.println(this.name +"  equals  "+p.name);
    
37.                 int num = this.name.compareTo(p.name);
    
38.                 if(num >0)
    
39.                         return false;
    
40.                 else if(num<0)
    
41.                         return false;
    
42.                 else if(this.age>p.age)
    
43.                         return false;
    
44.                 else if(this.age<p.age)
    
45.                         return false;
    
46.                 else return true;
    
47.                
    
48.         }
    
49. 
    
50.        
    
51. }
    
52. 
    
53. public class HashSetDemo {
    
54. 
    
55.         /**
    
56.          * @param args
    
57.          */
    
58.         public static void main(String[] args) {
    
59.                 // TODO Auto-generated method stub
    
60.                
    
61.                 HashSet hs = new HashSet();
    
62.                 PersonPractise lisi = new PersonPractise("lisi",25);
    
63.                 PersonPractise aaa = new PersonPractise("aaa",21);
    
64.                 PersonPractise zhangsan = new PersonPractise("zhangsan",25);
    
65.                 hs.add(lisi);
    
66.                 hs.add(aaa);
    
67.                 hs.add(lisi);
    
68.                 hs.add(zhangsan);
    
69.                 //调用removeHashSet没有再次调用equals方法，说明调用add方法时就记录下了比较结果，lz只能看源码了。。。。
    
70.                 hs.remove(zhangsan);
    
71.                 sop(hs);
    
72. 
    
73.         }
    
74.         public static void sop(HashSet hs){
    
75.                 Iterator it = hs.iterator();
    
76.                 while(it.hasNext()){
    
77.                         PersonPractise p =(PersonPractise)it.next();
    
78.                         System.out.println(p.getName()+"-----"+p.getAge());
    
79.                        
    
80.                 }
    
81.                        
    
82.                
    
83.         }
    
84. 
    
85. }
    

复制代码

HashCode()和equals()方法都根据是HashSet集合的底层数据结构调用的，这个就要清楚的了解哈希表的原理了，也就是说当你把对象地址存储到集合中的时候会自动的先后调用这两个方法。如果要查原理的话，可能就要去查看源码了。
还有你说的有一点错误，HashSet集合中对象的比较是先比较哈希地址值是否相同，相同的才会再次通过equals()方法来对比其内容是否相同。如果哈希地址值都不相同的，那么就没有必要再进行对象内容的比较了。这就是为什么要复写hashCode()方法的原因，这样可以减少比较的次数提高效率。

你重写一下hashcode方法，然后方法体直接返回一个1，就能证明了。来自: Android客户端