接着上面的思路：
3 重写Person类中的hashCode方法
运行程序，观察结果。
发现仍然有重复的元素，这是为什么呢？
这是因为在判断元素的哈希值之后，
如果哈希值相同，会调用equals方法判断内容是否一样。
这就要求：
4 重写equals方法.

1. import java.util.*;
   
2. //1 把数据存入Person,建立Person类
   
3. class Person
   
4. {
   
5.         private String name;//姓名
   
6.         private int age;//年龄
   
7. 
   
8.         Person(String name,int age)
   
9.         {
   
10.                 this.name = name;
    
11.                 this.age = age;
    
12.         }
    
13. 
    
14.         public void setName(String name)
    
15.         {
    
16.                 this.name = name;
    
17.         }
    
18. 
    
19.         public String getName()
    
20.         {
    
21.                 return name;
    
22.         }
    
23. 
    
24.         public void setAge(int age)
    
25.         {
    
26.                 this.age =age;
    
27.         }
    
28. 
    
29.         public int getAge()
    
30.         {
    
31.                 return age;
    
32.         }
    
33. 
    
34.         //重写hashCode方法
    
35.         public int hashCode()
    
36.         {
    
37.                 return name.hashCode()+age*37;
    
38.         }
    
39. 
    
40.         //重写equals方法
    
41.         public boolean equals(Object obj)
    
42.         {
    
43.                 //强制转换Person类型
    
44.                 Person p = (Person)obj;
    
45. 
    
46.                 //判断是否为同一个人
    
47.                 return this.getName().equals(p.getName()) && this.getAge()==p.getAge();
    
48.         }
    
49. }
    
50. 
    
51. //主类
    
52. class HashSetTest
    
53. {
    
54.         public static void main(String[] args)
    
55.         {
    
56.                 //1 创建HashSet集
    
57.                 HashSet hs = new HashSet();
    
58. 
    
59.                 //2 把Person对象存入集合
    
60.                 hs.add(new Person("Jack",20));
    
61.                 hs.add(new Person("Jack",20));
    
62.                 hs.add(new Person("Tom",18));
    
63.                 hs.add(new Person("Tom",18));
    
64.                 hs.add(new Person("Mike",19));
    
65.                 hs.add(new Person("Jane",26));
    
66. 
    
67.                 //3 取出元素
    
68.                 for(Iterator it = hs.iterator(); it.hasNext(); )
    
69.                 {
    
70.                         //强制转换为Person
    
71.                         Person p = (Person)it.next();
    
72.                         System.out.println(p.getName()+"---"+p.getAge());
    
73.                 }
    
74.         }
    
75. }
    

复制代码

/*
运行结果：


Tom---18
Jane---26
Jack---20
Mike---19
说明已经成功去重了，HashSet中已经不存在同名同年龄的人了！

总结：在HashSet中，存入元素是先判断哈希值是否一样，再判断内容是否一样！
hashset为了保证元素唯一：
1 如果元素哈希值相同，就判断equals是否为true；
2 如果哈希值不相同，不会调用equals方法。
此外，contains()和remove()等操作，HashSet都是依赖hashCode()和equals方法。
所以在类中必须重写这两个方法，才能保证元素唯一！

来看一看啊，给点分啊版主！