老紫竹JAVA提高教程(2)-认识Set集合之HashSet

原文地址：http://www.java2000.net/p11767

 集合在Java里面的作用非凡，我们常用的有Set,List和Map三种，我们先熟悉一下Set，特别是HashSet的使用

1. package collection.lession2;
3. import java.util.HashSet;
4. import java.util.Set;
6. /**
7.  * 老紫竹JAVA提高教程(2)-认识Set集合之HashSet。<br>
8.  * Set用来保存不允许重复的数据。可以是任何对象类型。<br>
9.  * JDK5以后，主类型可以通过autobox 放入Set里面。
10.  * 
11.  * @author 老紫竹 JAVA世纪网(java2000.net)
12.  * 
13.  */
14. public class Lession2 {
16.   public static void main(String[] args) {
17.     // 普通测试
18.     testNormal();
20.     // 测试HashSet的特殊性
21.     testForHashSet();
22.     testForHashSet2();
23.   }
25.   /**
26.    * 测试保存混合类型的数据.
27.    */
28.   public static void testNormal() {
29.     System.out.println("----- testNormal -----------");
30.     // Set有多个实现，我们先看看最常用的HashSet
31.     Set set = new HashSet();
32.     // 添加一个字符串
33.     set.add("字符串");
34.     // 添加一个整数对象
35.     set.add(new Integer(1));
36.     // 利用JDK5的特性，增加一个浮点数
37.     set.add(123.45);
39.     // 我们看看集合里对象的数量
40.     System.out.println(set.size());
42.     // 我们尝试增加一个重复的字符串
43.     set.add("字符串");
45.     // 我们再次看看集合里对象的数量
46.     System.out.println(set.size());
48.     // 我们来测试看看是否集合里包含了某个数据
49.     System.out.println(set.contains(123.45));
51.     // 我们从里面把这个浮点数删除
52.     set.remove(123.45);
54.     // 我们再次看看集合里对象的数量
55.     System.out.println(set.size());
56.   }
58.   /**
59.    * 专门针对HashSet的测试。
60.    */
61.   public static void testForHashSet() {
62.     System.out.println("----- testForHashSet -----------");
63.     HashSet<MyObject> set = new HashSet<MyObject>();
65.     // 增加一个null对象
66.     set.add(null);
67.     // 我们再次看看集合里对象的数量
68.     System.out.println(set.size());
69.     // 再次增加一个null看看
70.     set.add(null);
71.     // 我们再次看看集合里对象的数量
72.     System.out.println(set.size());
74.     MyObject obj = new MyObject("java2000", 2);
75.     set.add(obj);
77.     obj = new MyObject("csdn", 10);
78.     set.add(obj);
80.     // 我们再次看看集合里对象的数量
81.     System.out.println(set.size());
83.     // 判断是否包含某个对象
84.     System.out.println(set.contains(obj));
86.     obj = new MyObject("java2000_net", 2);
87.     set.add(obj);
89.     // 我们再次看看集合里对象的数量
90.     System.out.println(set.size());
92.     // 我们尝试把obj再次放入set看看
93.     // 并没有增加，因为是重复的
94.     set.add(obj);
95.     System.out.println(set.size());
97.     // 我们构造一个新的对象，内容和前面的相同
98.     obj = new MyObject("java2000_net", 2);
99.     set.add(obj);
100.     System.out.println(set.size());
102.     // 我们修改一下obj里面的年龄，再看看
103.     obj.setAge(3);
105.     // 我们再测试看看是否包含此对象。
106.     // 请注意，我们这个obj和前面的obj是同一个对象
107.     // 我们仅仅修改了一下我们的年龄
108.     System.out.println(set.contains(obj));
110.     // 我们尝试把obj再次放入set看看
111.     // 我们又增加了长度
112.     set.add(obj);
113.     System.out.println(set.size());
114.   }
116.   /**
117.    * 专门针对HashSet的测试2。
118.    */
119.   public static void testForHashSet2() {
120.     System.out.println("----- testForHashSet2 -----------");
121.     HashSet<MyObject2> set = new HashSet<MyObject2>();
122.     MyObject2 obj = null;
123.     for (int i = 0; i < 3; i++) {
124.       obj = new MyObject2("java2000" + i, i);
125.       set.add(obj);
126.       System.out.println(set.size());
127.     }
128.   }
130. }
132. class MyObject {
133.   private int age;
134.   private String name;
136.   public int getAge() {
137.     return age;
138.   }
140.   public void setAge(int age) {
141.     this.age = age;
142.   }
144.   public String getName() {
145.     return name;
146.   }
148.   public void setName(String name) {
149.     this.name = name;
150.   }
152.   MyObject(String name, int age) {
153.     this.name = name;
154.     this.age = age;
155.   }
157.   public boolean equals(Object obj) {
158.     System.out.println("equals");
159.     if (obj == null || !(obj instanceof MyObject)) {
160.       return false;
161.     }
162.     MyObject o = (MyObject) obj;
163.     return this.age == o.age && this.name.equals(o.name);
164.   }
166.   public int hashCode() {
167.     int hashCode = name.hashCode() + String.valueOf(age).hashCode();
168.     return hashCode;
169.   }
170. }
172. class MyObject2 {
173.   private int age;
174.   private String name;
176.   public int getAge() {
177.     return age;
178.   }
180.   public void setAge(int age) {
181.     this.age = age;
182.   }
184.   public String getName() {
185.     return name;
186.   }
188.   public void setName(String name) {
189.     this.name = name;
190.   }
192.   MyObject2(String name, int age) {
193.     this.name = name;
194.     this.age = age;
195.   }
197.   public boolean equals(Object obj) {
198.     System.out.println("equals");
199.     if (obj == null || !(obj instanceof MyObject2)) {
200.       return false;
201.     }
202.     MyObject2 o = (MyObject2) obj;
203.     return this.age == o.age && this.name.equals(o.name);
204.   }
206.   public int hashCode() {
207.     return 1;
208.   }
209. }
211. class MyObject3 {
212.   private int age;
213.   private String name;
215.   // 采用一个变量进行控制
216.   // 一旦生成了hashCode,则不再变动
217.   private int HASHCODE = Integer.MIN_VALUE;
219.   public int hashCode() {
220.     if (HASHCODE == Integer.MIN_VALUE) {
221.       // 重新生成本类的hashCode
222.       HASHCODE = name.hashCode() + String.valueOf(age).hashCode();
224.     }
225.     return HASHCODE;
226.   }
227. }

说明,针对HashSet：

• Set不允许重复
• 允许 null,重复的null只算一个
• 判断是否存在一个数据(是否重复)，先判断其hashCode是否存在，若存在再逐个判断hashCode相同的数据是否相等
• 判断是否相等，除了hashCode相等外，还要判断对象引用相等(==)，或者 equals
• 如果一个对象的hashCode变动了，会造成找不到这个对象，也就出现了内存泄漏的危险。

hashCode 方法是HashSet里面对象的关键，它的算法影响到了数据的分散和查找效率。某个确认对象的hashCode不应该变动，避免出现内存泄漏，可以采用如下方法，来方式属性变化造成hashCode变化

1. class MyObject3 {
2.   private int age;
3.   private String name;
5.   // 采用一个变量进行控制
6.   // 一旦生成了hashCode,则不再变动
7.   private int HASHCODE = Integer.MIN_VALUE;
9.   public int hashCode() {
10.     if (HASHCODE == Integer.MIN_VALUE) {
11.       // 重新生成本类的hashCode
12.       HASHCODE = name.hashCode() + String.valueOf(age).hashCode();
14.     }
15.     return HASHCODE;
16.   }
17. }