TreeSet类

1. package 集合类.Set类;  
2. /** 
3.  * Set不允许重复数据 
4.  */  
5.   
6.   
7. /** 
8.  * TreeSet 是用来进行集合排序的，请注意他和LinkedHashSet的区别。　 
9.  TreeSet是按照一定的规则，将加入到集合里面的数据进行排序， 
10.  而LinkedHashSet是严格按照你放入集合的顺序进行使用 
11.  * @author jjj 
12.  */  
13. import java.util.Arrays;  
14. import java.util.Comparator;  
15. import java.util.Set;  
16. import java.util.TreeSet;  
17.   
18. public class TreeSet类 {  
19.     public static void main(String[] args) {  
20.         // 测试自然排序  
21.         testNature();  
22.   
23.         // 测试指定排序方式  
24.         testComparator();  
25.   
26.         // 测试特殊的混合对象排序  
27.         testMix();  
28.     }  
29.   
30.     public static void testNature() {  
31.         // 测试一下数字  
32.         TreeSet<Integer> set = new TreeSet<Integer>();  
33.         // 反向存入整数数据  
34.         for (int i = 10; i >= 1; i--) {  
35.             set.add(i);  
36.         }  
37.         //如果add了相同的数据，是无效的，因为set集合不能重复元素  
38.         set.add(10);  
39.         // 输出看看  
40.         // 可以看到数据为自然的数字排序  
41.         showSet(set); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
42.   
43.         // 测试一下字符串  
44.         TreeSet<String> set2 = new TreeSet<String>();  
45.         // 同样反向放入  
46.         for (int i = 10; i >= 1; i--) {  
47.             set2.add(i + "");  
48.         }  
49.         // 看输出结果  
50.         // 10 的自然排序没有2高，因为字符'1'小于'2'  
51.         showSet(set2); // [1, 10, 2, 3, 4, 5, 6, 7, 8, 9]  
52.   
53.         // TreeSet里面的数据因为要排队  
54.         // 所以如果是混合类型数据的数据，如果不能字段转换  
55.         // 将出现异常 java.lang.ClassCastException:  
56.     }  
57.   
58.     public static void testComparator() {  
59.         // 同样测试数字，我们要反向排序  
60.         TreeSet<Integer> set = new TreeSet<Integer>(new MyIntegerComparator());  
61.         // 反向存入整数数据  
62.         for (int i = 10; i >= 1; i--) {  
63.             set.add(i);  
64.         }  
65.         // 输出看看  
66.         // 可以看到数据为我们期望的反向排序了  
67.         showSet(set); // [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]  
68.   
69.         // 我们指定更奇怪的排序，奇数在前面，偶数在后面  
70.         // 我们使用匿名内部类  
71.         TreeSet<Integer> set2 = new TreeSet<Integer>(new Comparator<Integer>() {  
72.   
73.             public int compare(Integer o1, Integer o2) {  
74.                 if (o1 % 2 != 0) {  
75.                     if (o2 % 2 != 0) {  
76.                         return o2.compareTo(o1);  
77.                     }  
78.                     return -1;  
79.                 }  
80.                 if (o2 % 2 != 0) {  
81.                     return 1;  
82.                 }  
83.                 return o2.compareTo(o1);  
84.             }  
85.         });  
86.         // 反向存入整数数据  
87.         for (int i = 10; i >= 1; i--) {  
88.             set2.add(i);  
89.         }  
90.         // 输出看看  
91.         // 可以看到数据，技术的在前面，且从大到小排序  
92.         // 偶数在后面，也是从大到小排序  
93.         showSet(set2); // [9, 7, 5, 3, 1, 10, 8, 6, 4, 2]  
94.   
95.     }  
96.   
97.     /** 
98.      * 混合对象，你要为每个对象类型进行计较控制，避免出现转换异常. 
99.      */  
100.     public static void testMix() {  
101.         // 我们测试混合类型的对象，比如字符串和整数  
102.         // 如果我们不指定自己的比较器，而使用默认的自然比较器  
103.         // 将发生异常  
104.         TreeSet set = new TreeSet(new Comparator() {  
105.   
106.             public int compare(Object o1, Object o2) {  
107.                 // 我们用字符串比较好了  
108.                 return o1.toString().compareTo(o2.toString());  
109.             }  
110.   
111.         });  
112.         for (int i = 10; i >= 1; i--) {  
113.             set.add(i); // 存入整数  
114.             set.add(i + ""); // 存入字符串  
115.         }  
116.         // 输出看看  
117.         // 里面的内容确实按照字符串进行排序了。  
118.         // 数字被转化为字符串再参与比较。  
119.         showSet(set); // [1, 10, 2, 3, 4, 5, 6, 7, 8, 9]  
120.     }  
121.   
122.     /** 
123.      * 显示Set里面的数据。 
124.      *  
125.      * @param set 
126.      */  
127.     private static void showSet(Set set) {  
128.         System.out.println(Arrays.toString(set.toArray()));  
129.     }  
130. }  
131.   
132. // 注意，我指定了强制类型的比较器  
133. class MyIntegerComparator implements Comparator<Integer> {  
134.   
135.     public int compare(Integer o1, Integer o2) {  
136.         return o2.compareTo(o1);// 使用反向的比较  
137.     }  
138. }