java集合Set操作

1. package Sets;   
2. import java.util.HashSet;   
3. import java.util.Iterator;   
4. import java.util.Set;   
5. import java.util.TreeSet;   
6.   
7. /**  
8.  * java集合操作  
9.  *   
10.  * @author baby69yy2000  
11.  *   
12.  */  
13. public class Sets {   
14.   
15.     /** 求并集 */  
16.     public static <T> Set<T> union(Set<T> setA, Set<T> setB) {   
17.         Set<T> setUnion;   
18.   
19.         if (setA instanceof TreeSet)   
20.             setUnion = new TreeSet<T>();   
21.         else  
22.             setUnion = new HashSet<T>();   
23.   
24.         Iterator<T> iterA = setA.iterator();   
25.         while (iterA.hasNext())   
26.             setUnion.add(iterA.next());   
27.   
28.         Iterator<T> iterB = setB.iterator();   
29.         while (iterB.hasNext())   
30.             setUnion.add(iterB.next());   
31.         return setUnion;   
32.     }   
33.   
34.     /** 求交集 */  
35.     public static <T> Set<T> intersection(Set<T> setA, Set<T> setB) {   
36.         Set<T> setIntersection;   
37.         T item;   
38.   
39.         if (setA instanceof TreeSet)   
40.             setIntersection = new TreeSet<T>();   
41.         else  
42.             setIntersection = new HashSet<T>();   
43.   
44.         Iterator<T> iterA = setA.iterator();   
45.         while (iterA.hasNext()) {   
46.             item = iterA.next();   
47.             if (setB.contains(item))   
48.                 setIntersection.add(item);   
49.         }   
50.         return setIntersection;   
51.     }   
52.   
53.     /** 求差集 */  
54.     public static <T> Set<T> difference(Set<T> setA, Set<T> setB) {   
55.         Set<T> setDifference;   
56.         T item;   
57.   
58.         if (setA instanceof TreeSet)   
59.             setDifference = new TreeSet<T>();   
60.         else  
61.             setDifference = new HashSet<T>();   
62.   
63.         Iterator<T> iterA = setA.iterator();   
64.         while (iterA.hasNext()) {   
65.             item = iterA.next();   
66.             if (!setB.contains(item))   
67.                 setDifference.add(item);   
68.         }   
69.         return setDifference;   
70.     }   
71.   
72.     /**  
73.      * 判断子集操作 判断setA中的每个元素是否也存在于setB中  
74.      */  
75.     public static <T> boolean subset(Set<T> setA, Set<T> setB) {   
76.         return intersection(setA, setB).size() == setA.size();   
77.     }   
78.   
79.     /********************************下面是有序集的操作********************************/  
80.        
81.     /** 求交集 */  
82.     public static <T extends Comparable<? super T>> TreeSet<T> orderedIntersection(   
83.             Set<T> a, Set<T> b) {   
84.         TreeSet<T> setIntersection = new TreeSet<T>();   
85.         Iterator<T> iterA = a.iterator(),   
86.                     iterB = b.iterator();   
87.         T valueA, valueB;   
88.            
89.         valueA = advance(iterA);   
90.         valueB = advance(iterB);   
91.         while(valueA != null && valueB != null) {   
92.             if(valueA.compareTo(valueB) < 0)   
93.                 valueA = advance(iterA);   
94.             else if(valueB.compareTo(valueA) < 0)   
95.                 valueB = advance(iterB);   
96.             else {   
97.                 setIntersection.add(valueA);   
98.                 valueA = advance(iterA);   
99.                 valueB = advance(iterB);   
100.             }   
101.         }   
102.         return setIntersection;   
103.     }   
104.        
105.     private static <T> T advance(Iterator<T> iter) {   
106.         T value = null;   
107.         if (iter.hasNext())   
108.             value = iter.next();   
109.         return value;   
110.     }   
111. }  

/** 求差集 */
public static <T> Set<T> difference( Set<T> setA, Set<T> setB) {
Set<T> setDifference;
T item;

if (setA instanceof TreeSet) {
setDifference = new TreeSet<T>();
} else {
setDifference = new HashSet<T>();
}

               // 判断一下集合的数量大小 再比较
if (setA.size() > setB.size()) {
Iterator<T> iterA = setA.iterator();
while (iterA.hasNext()) {
item = iterA.next();
if (!setB.contains(item)) {
setDifference.add(item);
}
}
} else {
Iterator<T> iterB = setB.iterator();
while (iterB.hasNext()) {
item = iterB.next();
if (!setA.contains(item)) {
setDifference.add(item);
}
}
}

return setDifference;
}