1、java中的集合類總結2008年09月28日 星期日 下午 12:39在使用Java的時候，我們都會遇到使用集合（Collection）的時候，但是Java API提供了多種集合的實現，我在使用和面試的時候頻頻遇到這樣的“抉擇” 。 :）（主要還是面試的時候）久而久之，也就有了一點點的心得體會，寫出來以供大家討論 ?？偟恼f來，Java API中所用的集合類，都是實現了Collection接口，他的一個類繼承結構如下：Collection<-List<-VectorCollection<-List<-ArrayListCollection<-List<-Lin

2、kedListCollection<-Set<-HashSetCollection<-Set<-HashSet<-LinkedHashSetCollection<-Set<-SortedSet<-TreeSetVector : 基于Array的List，其實就是封裝了Array所不具備的一些功能方便我們使用，它不可能走入Array的限制。性能也就不可能超越Array。所以，在可能的情況下，我們要多運用Array。另外很重要的一點就是Vector“sychronized”的，這個也是Vector和ArrayList的唯一的區別。ArrayList：

3、同Vector一樣是一個基于Array上的鏈表，但是不同的是ArrayList不是同步的。所以在性能上要比Vector優越一些，但是當運行到多線程環境中時，可需要自己在管理線程的同步問題。LinkedList：LinkedList不同于前面兩種List，它不是基于Array的，所以不受Array性能的限制。它每一個節點（Node）都包含兩方面的內容：1.節點本身的數據（data）；2.下一個節點的信息（nextNode）。所以當對LinkedList做添加，刪除動作的時候就不用像基于Array的List一樣，必須進行大量的數據移動。只要更改nextNode的相關信息就可以實現了。這就是Link

4、edList的優勢。List總結：1. 所有的List中只能容納單個不同類型的對象組成的表，而不是KeyValue鍵值對。例如： tom,1,c ；2. 所有的List中可以有相同的元素，例如Vector中可以有 tom,koo,too,koo ；3. 所有的List中可以有null元素，例如 tom,null,1 ；4. 基于Array的List（Vector，ArrayList）適合查詢，而LinkedList（鏈表）適合添加，刪除操作。HashSet：雖然Set同List都實現了Collection接口，但是他們的實現方式卻大不一樣。List基本上都是以Array為基礎。但是Set則是在

5、HashMap的基礎上來實現的，這個就是Set和List的根本區別。HashSet的存儲方式是把HashMap中的Key作為Set的對應存儲項。看看HashSet的add（Object obj）方法的實現就可以一目了然了。public boolean add(Object obj)return map.put(obj, PRESENT) = null;這個也是為什么在Set中不能像在List中一樣有重復的項的根本原因，因為HashMap的key是不能有重復的。LinkedHashSet：HashSet的一個子類，一個鏈表。TreeSet：SortedSet的子類，它不同于HashSet的根本就

6、是TreeSet是有序的。它是通過SortedMap來實現的。Set總結：1. Set實現的基礎是Map（HashMap）；2. Set中的元素是不能重復的，如果使用add(Object obj)方法添加已經存在的對象，則會覆蓋前面的對象為什么要使用集合類當你事先不知道要存放數據的個數，或者你需要一種比數組下標存取機制更靈活的方法時，你就需要用到集合類。理解集合類集合類存放于java.util包中。集合類存放的都是對象的引用，而非對象本身，出于表達上的便利，我們稱集合中的對象就是指集合中對象的引用（reference)。集合類型主要有3種：set(集）、list(列表）和map(映射)。(1)

7、集集（set）是最簡單的一種集合，它的對象不按特定方式排序，只是簡單的把對象加入集合中，就像往口袋里放東西。對集中成員的訪問和操作是通過集中對象的引用進行的，所以集中不能有重復對象。集也有多種變體，可以實現排序等功能，如TreeSet，它把對象添加到集中的操作將變為按照某種比較規則將其插入到有序的對象序列中。它實現的是SortedSet接口，也就是加入了對象比較的方法。通過對集中的對象迭代，我們可以得到一個升序的對象集合。(2)列表列表的主要特征是其對象以線性方式存儲，沒有特定順序，只有一個開頭和一個結尾，當然，它與根本沒有順序的集是不同的。列表在數據結構中分別表現為：數組和向量、鏈表、堆棧、

8、隊列。關于實現列表的集合類，是我們日常工作中經常用到的，將在后邊的筆記詳細介紹。(3)映射映射與集或列表有明顯區別，映射中每個項都是成對的。映射中存儲的每個對象都有一個相關的關鍵字（Key）對象，關鍵字決定了對象在映射中的存儲位置，檢索對象時必須提供相應的關鍵字，就像在字典中查單詞一樣。關鍵字應該是唯一的。關鍵字本身并不能決定對象的存儲位置，它需要對過一種散列(hashing)技術來處理，產生一個被稱作散列碼(hash code)的整數值，散列碼通常用作一個偏置量，該偏置量是相對于分配給映射的內存區域起始位置的，由此確定關鍵字/對象對的存儲位置。理想情況下，散列處理應該產生給定范圍內均勻分布的

9、值，而且每個關鍵字應得到不同的散列碼。集合類簡介java.util中共有13個類可用于管理集合對象，它們支持集、列表或映射等集合，以下是這些類的簡單介紹集：HashSet： 使用HashMap的一個集的實現。雖然集定義成無序，但必須存在某種方法能相當高效地找到一個對象。使用一個HashMap對象實現集的存儲和檢索操作是在固定時間內實現的.TreeSet： 在集中以升序對對象排序的集的實現。這意味著從一個TreeSet對象獲得第一個迭代器將按升序提供對象。TreeSet類使用了一個TreeMap.列表：Vector： 實現一個類似數組一樣的表，自動增加容量來容納你所需的元素。使用下標存儲和檢索對

10、象就象在一個標準的數組中一樣。你也可以用一個迭代器從一個Vector中檢索對象。Vector是唯一的同步容器類?當兩個或多個線程同時訪問時也是性能良好的。Stsck: 這個類從Vector派生而來，并且增加了方法實現棧?一種后進先出的存儲結構。LinkedList: 實現一個鏈表。由這個類定義的鏈表也可以像?；蜿犃幸粯颖皇褂?。ArrayList: 實現一個數組，它的規模可變并且能像鏈表一樣被訪問。它提供的功能類似Vector類但不同步。映射：HashTable： 實現一個映象，所有的鍵必須非空。為了能高效的工作，定義鍵的類必須實現hashcode()方法和equal()方法。這個類是前面jav

11、a實現的一個繼承，并且通常能在實現映象的其他類中更好的使用。HashMap： 實現一個映象，允許存儲空對象，而且允許鍵是空（由于鍵必須是唯一的，當然只能有一個）。WeakHashMap： 實現這樣一個映象：通常如果一個鍵對一個對象而言不再被引用，鍵/對象對將被舍棄。這與HashMap形成對照，映象中的鍵維持鍵/對象對的生命周期，盡管使用映象的程序不再有對鍵的引用，并且因此不能檢索對象。TreeMap： 實現這樣一個映象，對象是按鍵升序排列的。Set和List都是由公共接口Collection擴展而來，所以它們都可以使用一個類型為Collection的變量來引用。這就意味著任何列表或集構成的集合

12、都可以用這種方式引用，只有映射類除外（但也不是完全排除在外，因為可以從映射獲得一個列表。）所以說，把一個列表或集傳遞給方法的標準途徑是使用Collection類型的參數。Vector 還是ArrayList，哪一個更好，為什么？要回答這個問題不能一概而論，有時候使用Vector比較好；有時是ArrayList，有時候這兩個都不是最好的選擇。你別指望能夠獲得一個簡單肯定答案，因為這要看你用它們干什么。下面有4個要考慮的因素：(1)API(2)同步處理(3)數據增長性(4)使用模式下面針對這4個方面進行一一探討API在由Ken Arnold等編著的Java Programming Language

13、(Addison-Wesley, June 2000)一書中有這樣的描述，Vector類似于ArrayList.。所有從API的角度來看這兩個類非常相似。但他們之間也還是有一些主要的區別的。同步性Vector是同步的。這個類中的一些方法保證了Vector中的對象是線程安全的。而ArrayList則是異步的，因此ArrayList中的對象并不是線程安全的。因為同步的要求會影響執行的效率，所以如果你不需要線程安全的集合那么使用ArrayList是一個很好的選擇，這樣可以避免由于同步帶來的不必要的性能開銷。數據增長從內部實現機制來講ArrayList和Vector都是使用數組(Array)來控制集合

14、中的對象。當你向這兩種類型中增加元素的時候，如果元素的數目超出了內部數組目前的長度它們都需要擴展內部數組的長度，Vector缺省情況下自動增長原來一倍的數組長度，ArrayList是原來的50%,所以最后你獲得的這個集合所占的空間總是比你實際需要的要大。所以如果你要在集合中保存大量的數據那么使用Vector有一些優勢，因為你可以通過設置集合的初始化大小來避免不必要的資源開銷。使用模式在ArrayList和Vector中，從一個指定的位置（通過索引）查找數據或是在集合的末尾增加、移除一個元素所花費的時間是一樣的，這個時間我們用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花費的時間會

15、呈線形增長：O(n-i)，其中n代表集合中元素的個數，i代表元素增加或移除元素的索引位置。為什么會這樣呢？以為在進行上述操作的時候集合中第i和第i個元素之后的所有元素都要執行位移的操作。這一切意味著什么呢？這意味著，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好選擇其他的集合操作類。比如，LinkList集合類在增加或移除集合中任何位置的元素所花費的時間都是一樣的O(1)，但它在索引一個元素的使用缺比較慢O(i),其中i是索引的位置.使用ArrayList也很容易，因為你可以簡單的使用索引來代替創建iterator

16、對象的操作。LinkList也會為每個插入的元素創建對象，所有你要明白它也會帶來額外的開銷。最后，在Practical Java一書中Peter Haggar建議使用一個簡單的數組（Array）來代替Vector或ArrayList。尤其是對于執行效率要求高的程序更應如此。因為使用數組(Array)避免了同步、額外的方法調用和不必要的重新分配空間的操作。(T007)import java.util.*;public class Testset public static void main(String args) Set set = new HashSet(); set.add("

17、aaa"); set.add("bbb"); set.add("aaa"); set.add("bbb"); set.add("aaa"); set.add("bbb"); set.add("aaa"); set.add("bbb"); set.add("aaa"); set.add("bbb"); Iterator ite=set.iterator(); set.size(); while(ite.has

18、Next() System.out.println("-"+ite.next(); JAVA中的集合類我們看一個簡單的例子，來了解一下集合類的基本方法的使用：import java.util.*; public class CollectionToArray public static void main(String args) Collection collection1=new ArrayList();/創建一個集合對象 collection1.add("000");/添加對象到Collection集合中 collection1.add("

19、;111"); collection1.add("222"); System.out.println("集合collection1的大小："+collection1.size(); System.out.println("集合collection1的內容："+collection1); collection1.remove("000");/從集合collection1中移除掉 "000" 這個對象 System.out.println("集合collection1移除 000

20、 后的內容："+collection1); System.out.println("集合collection1中是否包含000 ："+collection1.contains("000"); System.out.println("集合collection1中是否包含111 ："+collection1.contains("111"); Collection collection2=new ArrayList(); collection2.addAll(collection1);/將collection1

21、 集合中的元素全部都加到collection2中 System.out.println("集合collection2的內容："+collection2); collection2.clear();/清空集合 collection1 中的元素 System.out.println("集合collection2是否為空 ："+collection2.isEmpty(); /將集合collection1轉化為數組 Object s= collection1.toArray(); for(int i=0;i    運行結果為：集合c

22、ollection1的大?。? 集合collection1的內容：000, 111, 222 集合collection1移除 000 后的內容：111, 222 集合collection1中是否包含000 ：false 集合collection1中是否包含111 ：true 集合collection2的內容：111, 222 集合collection2是否為空 ：true 111 222    這里需要注意的是，Collection 它僅僅只是一個接口，而我們真正使用的時候，確是創建該接口的一個實現類。做為集合的接口，它定義了所有屬于集合的類所都應該具有的一些方法

23、。    而ArrayList （列表）類是集合類的一種實現方式。    下面，我們看一個對于迭代器的簡單使用：import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class IteratorDemo public static void main(String args) Collection collection = new ArrayList(); collection.add("s1&qu

24、ot;); collection.add("s2"); collection.add("s3"); Iterator iterator = collection.iterator();/得到一個迭代器 while (iterator.hasNext() /遍歷 Object element = iterator.next(); System.out.println("iterator = " + element); if(collection.isEmpty() System.out.println("collection

25、is Empty!"); else System.out.println("collection is not Empty! size="+collection.size(); Iterator iterator2 = collection.iterator(); while (iterator2.hasNext() /移除元素 Object element = iterator2.next(); System.out.println("remove: "+element); iterator2.remove(); Iterator itera

26、tor3 = collection.iterator(); if (!iterator3.hasNext() /察看是否還有元素 System.out.println("還有元素"); if(collection.isEmpty() System.out.println("collection is Empty!"); /使用collection.isEmpty()方法來判斷     程序的運行結果為：iterator = s1 iterator = s2 iterator = s3 collection is not Em

27、pty! size=3 remove: s1 remove: s2 remove: s3    還有元素    collection is Empty！    可以看到，Java的Collection的Iterator 能夠用來，：    1） 使用方法iterator（） 要求容器返回一個Iterator .第一次調用Iterator 的next（） 方法時，它返回集合序列的第一個元素。    2） 使用next（） 獲得集合序列的中的下一個元

28、素。    3） 使用hasNext（）檢查序列中是否元素。    4） 使用remove（）將迭代器新返回的元素刪除。    需要注意的是：方法刪除由next方法返回的最后一個元素，在每次調用next時，remove方法只能被調用一次 .    大家看，Java 實現的這個迭代器的使用就是如此的簡單。Iterator（跌代器）雖然功能簡單，但仍然可以幫助我們解決許多問題，同時針對List 還有一個更復雜更高級的ListIterator.您可以在下面的List講解中得到進一步

29、的介紹。    我們看一個List的例子：import java.util.*; public class ListIteratorTest public static void main(String args) List list = new ArrayList(); list.add("aaa"); list.add("bbb"); list.add("ccc"); list.add("ddd"); System.out.println("下標0開始："+li

30、st.listIterator(0).next();/next() System.out.println("下標1開始:"+list.listIterator(1).next(); System.out.println("子List 1-3:"+list.subList(1,3);/子列表 ListIterator it = list.listIterator();/默認從下標0開始 /隱式光標屬性add操作 ,插入到當前的下標的前面 it.add("sss"); while(it.hasNext() System.out.print

31、ln("next Index="+it.nextIndex()+",Object="+it.next(); /set屬性 ListIterator it1 = list.listIterator(); it1.next(); it1.set("ooo"); ListIterator it2 = list.listIterator(list.size();/下標 while(it2.hasPrevious() System.out.println("previous Index="+it2.previousIndex

32、()+",Object="+it2.previous();     程序的執行結果為：下標0開始：aaa 下標1開始:bbb 子List 1-3:bbb, ccc next Index=1,Object=aaa next Index=2,Object=bbb next Index=3,Object=ccc next Index=4,Object=ddd previous Index=4,Object=ddd previous Index=3,Object=ccc previous Index=2,Object=bbb previous Inde

33、x=1,Object=a一、用得最多的主要有Set,List,Map,Iterator這幾個接口, Set和List接口都是Collection接口的子接口,有很多相同的地方，我們只是撐握了Collection接口的方法，Set和List的用法也就差不多了.      Set和List 的區別：1、Set是沒有順序的，不能放重復的數據(相同的數據)                

34、;                  2、List是有順序的，可以存放重復的數據(相同的數據)Set的實現類常用的主要有兩個：HashSet、TreeSet      我們可以把一類對象添加到集合中，并且按對象的某一個屬性進行排序（客戶化排序和自然排序)      1、對TreeSet集進行客戶化排

35、序要求寫一個類實現Comparator接口，并且重寫其中的Compare方法 例:      客戶化排序容易擴展，如果要按其它的屬性排序，只需要重新寫一個類實現Comparator接口就可以了，      不需要修改原來的代碼。      class Users              

36、    private String name;           private int id;           public Users(String name,int id)                &

37、#160;          =name;                this.id=id;                     

38、public void setName(String name)                            =name;                  &

39、#160;   public String getName()                              return name;             

40、0;        public void setId(int id)                             this.id=id;        &#

41、160;             public int getId()                            return id;       

42、               /這里重寫了父類的toString方法            public String toString()                    

43、         retur + "t" + this.id + "t"                        /這個類實現Comparator接口，并且重寫了其中的compare方法   &

44、#160;  public class MyComparator implements Comparator                public int  compare(Object o1,Object o2)                 

45、60;         Users user1=(Users)o1;                Users user2=(Users)o2;                if(user

46、1.getId>user2.getId) return 1;                else if(user1.getId=user2.getId) return 0;                return -1;    

47、;                 class  TestComparator               public static void main(String args)          

48、               TestComparator.test();                    public static void test()        

49、                    Set   set=new TreeSet(new MyComparator();                  Users user1=new 

50、 Users("張三",17);                  Users user2=new  Users("李四",13);                  U

51、sers user3=new  Users("王五",19);                  Users user5=new Users("王五",19);                

52、0; set.add(user1);                  set.add(user2);                  set.add(user3);     &

53、#160;            set.add(user5);                                  

54、0; for(Object obj ：set)                                          System.out.println(o

55、bj);                                      2、自然排序，將需要排序的那個類實現Comparable接口并且重寫其中的compareTo方法     

56、     例如下:      class Users  implements Comparable                 private String name;           private

57、int id;           public Users(String name,int id)                           =name;      &

58、#160;         this.id=id;                      public void setName(String name)             

59、60;              =name;                      public String getName()            

60、                  return name;                      public void setId(int id)      &#

61、160;                      this.id=id;                      public int getId()   

62、                         return id;                      /這里重寫了父類的toString方法  &#

63、160;         public String toString()                             retur + "t" + this.id + "t" &

64、#160;                      /重寫compareTo方法             public int compareTo(Object o)        

65、60;                             UserBean user = (UserBean) o;                  &

66、#160;  if (this.id > user.id) return 1;                     else if (this.id = user.id) return 0;                

67、;      return -1;                         3.如果是HashSet自然排序，則要求排序的類重寫hashCode方法和equals方法      二、對List和Set集進行遍歷： 

68、0;     List集有三種方法進行遍歷：       1、通過下標遍歷,2使用迭代器進行遍歷，3、增強循環進行遍歷       List list=new ArrayList();       list.add("aa");       list.add("bb");

69、0;      list.add("cc");       for(int i=0;i<list.size();i+)                System.out.println(list.get(i);       

70、0;         Iterator it=list.iterator();     while(it.hasNext()             System.out.println(it.next();             for

71、(Object obj ：list)              System.out.println(obj);        三、Vector和ArrayList的區別:    1、Vector 和ArrayList都實現了List接口，Vector是線程安全的，可以多個線程同時訪問,但性能比較差   &#

72、160;2、ArrayList線程不安全，不支持多個線程同時訪問，但性能比較好，訪問的速度快        四、Map集是以鍵值對的形式存放的，鍵不可以重復，值可以重復，如果鍵重復，會將原來的值覆蓋，     Map集的實現類主要有三個:HashMap,TreeMap,HashTable    HashMap與HashTable 的區別: 1、HashTable是線程安全的，支持同步。2、HashMap線程不安全，不支持 &#

73、160;  同步，但性能比HashTable好    Map集的遍歷：      1、      Map map=new HashMap()      map.put("1","張飛");      map.put("2","關羽

74、");      map.put("3","劉備");      /得到鍵的集合      Set set=map.keySet();      for(Object obj ：set)          &#

75、160;     System.out.println(map.get(obj);            2、      /得到健值對的集合      Set s=map.entrySet();       for(Object obj ：set)&

76、#160;               System.out.println(obj);         五、對List集進行客戶化排序，可以通過Collections類的sort方法，要求傳一個List集和一個Comparator對象 例：      List list=new ArrayList()

77、60;     Users user1=new  Users("張三",17);      Users user2=new  Users("李四",13);      Users user3=new  Users("王五",19);      Use

78、rs user5=new Users("王五",19);      list.add(user1);      list.add(user2);      list.add(user3);      list.add(user5);      Collections.sort(l

79、ist,new Mycomparator();      Iterator it=list.iterator();      while(it.hasNext()                 System.out.println(it.next();     

80、60;JAVA中的集合類(2007-01-05 19:22:11)  分類：培訓筆記為什么要使用集合類當你事先不知道要存放數據的個數，或者你需要一種比數組下標存取機制更靈活的方法時，你就需要用到集合類。理解集合類集合類存放于java.util包中。集合類存放的都是對象的引用，而非對象本身，出于表達上的便利，我們稱集合中的對象就是指集合中對象的引用（reference)。集合類型主要有3種：set(集）、list(列表）和map(映射)。(1)集集（set）是最簡單的一種集合，它的對象不按特定方式排序，只是簡單的把對象加入集合中，就像往口袋里放東西。對集中成員的訪問和操作是通過集中對象的引用進行的，所以集中不能有重復對象。集也有多種變體，可以實現排序等功能，如TreeSet，它把對象添加到集中的操作將變為按照某種比較規則將其插入到有序的對象序列中。它實現的是SortedSet接口，也就是加入了對象比較的方法。通過對集中的對象迭代，我們可以得到一個升序的對象集合。(2)列表列表的主要特征是其