HashSet、LinkedHashSet和TreeSet

[plain] view plaincopyprint?

1. 關鍵技術：  

2.   

3.     HashSet採用散列函數對元素進行排序，是專門爲快速查詢而設計的。存入HashSet的對象必須定義hashCode方法。  

4.     TreeSet採用紅黑樹的數據結構進行排序元素，使用它能夠從Set中提取有序（升序或者降序）的序列。須要注意的是，存入自定義類時，TreeSet須要維護元素的存儲順序，所以自定義類要實現Comparable接口並定義compareTo方法。  

5.     LinkedHashSet內部使用散列以加快查詢速度，同時使用鏈表維護元素插入的次序，在使用迭代器遍歷Set時，結果會按元素插入的次序顯示。  

[java] view plaincopyprint?

1. package book.arrayset;  

2.   

3. import java.util.ArrayList;  

4. import java.util.HashSet;  

5. import java.util.Iterator;  

6. import java.util.LinkedHashSet;  

7. import java.util.List;  

8. import java.util.Set;  

9. import java.util.TreeSet;  

10.   

11. /** 

12.  * 演示各類Set的使用 

13.  * 存入Set的每一個元素必須是惟一的，由於Set不保存重複元素。 

14.  */  

15. public class TestSet {  

16.   

17.     /** 

18.      * 初始化Set的元素 

19.      * @param set 

20.      */  

21.     public static void init(Set set){  

22.         if (set != null){  

23.             set.add("aaa");  

24.             set.add("ccc");  

25.             set.add("bbb");  

26.             set.add("eee");  

27.             set.add("ddd");  

28.         }  

29.     }  

30.     /** 

31.      * 輸出set的元素 

32.      * @param set 

33.      */  

34.     public static void output(Set set){  

35.         if (set != null){  

36.             //使用迭代器遍歷Set，也只有這一種方法  

37.             Iterator it = set.iterator();  

38.             while (it.hasNext()){  

39.                 System.out.print(it.next() + " ");  

40.             }  

41.         }  

42.         System.out.println();  

43.     }  

44.     /** 

45.      * 使用HashSet 

46.      */  

47.     public static void testHashSet(){  

48.         Set mySet = new HashSet();  

49.         init(mySet);  

50.         System.out.println("使用HashSet: ");  

51.         output(mySet);  

52.     }  

53.     /** 

54.      * 使用TreeSet 

55.      */  

56.     public static void testTreeSet(){  

57.         Set mySet = new TreeSet();  

58.         init(mySet);  

59.         System.out.println("使用TreeSet: ");  

60.         output(mySet);  

61.     }  

62.     /** 

63.      * 使用LinkedHashSet 

64.      */  

65.     public static void testLinkedHashSet(){  

66.         Set mySet = new LinkedHashSet();  

67.         init(mySet);  

68.         System.out.println("使用LinkedHashSet: ");  

69.         output(mySet);  

70.     }  

71.     public static void main(String[] args) {  

72.         TestSet.testHashSet();  

73.         TestSet.testTreeSet();  

74.         TestSet.testLinkedHashSet();  

75.           

76.         Set mySet = new HashSet();  

77.         init(mySet);  

78.         //Set不容許元素重複  

79.         mySet.add("aaa");  

80.         mySet.add("bbb");  

81.         System.out.println("爲mySet加入aaa, bbb元素後: ");  

82.         output(mySet);  

83.         //刪除元素  

84.         mySet.remove("aaa");  

85.         System.out.println("mySet刪除aaa元素後: ");  

86.         output(mySet);  

87.         //增長另一個集合中的全部元素  

88.         List list = new ArrayList();  

89.         list.add("aaa");  

90.         list.add("aaa");  

91.         list.add("fff");  

92.         mySet.addAll(list);  

93.         System.out.println("mySet添加另一個集合的全部元素後: ");  

94.         output(mySet);  

95.         //刪除除了另一個集合包含的之外的全部元素  

96.         mySet.retainAll(list);  

97.         System.out.println("mySet刪除除了另一個集合包含的之外的全部元素後: ");  

98.         output(mySet);  

99.         //刪除另一個集合包含的全部元素  

100.         mySet.removeAll(list);  

101.         System.out.println("mySet刪除另一個集合包含的全部元素後: ");  

102.         output(mySet);  

103.         //獲取Set中元素的個數  

104.         System.out.println("mySet中當前元素的個數: " + mySet.size());  

105.         //判斷Set中元素個數是否爲0  

106.         System.out.println("mySet中當前元素爲0？  " + mySet.isEmpty());  

107.           

108.         /** 

109.          * （1）Set不容許重複元素，所以加入Set的Object必須定義equals()方法以確保對象的惟一性。 

110.          * （2）HashSet採用散列函數對元素進行排序，是專門爲快速查詢而設計的。存入HashSet的對象必須定義hashCode()。 

111.          * （3）TreeSet採用紅黑樹的數據結構進行排序元素，能保證元素的次序，使用它能夠從Set中提取有序的序列。 

112.          * 須要注意的是，生成本身的類時，Set須要維護元素的存儲順序，所以要實現Comparable接口並定義compareTo()方法。 

113.          * （4）LinkedHashSet內部使用散列以加快查詢速度，同時使用鏈表維護元素的插入的次序，在使用迭代器遍歷Set時，結果會按元素插入的次序顯示。 

114.      */  

115.     }  

116. }