Java程序设计4——集合类
1 JAVA集合概述 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ??
Java集合封裝了一系列數(shù)據(jù)結(jié)構(gòu)比如鏈表、二叉樹、棧、隊列等，然后提供了針對這些數(shù)據(jù)結(jié)構(gòu)的一系列算法比如查找、排序、替換，使編程難度大大降低。（這句話有可能是非法的，因為個人對算法目前不是太了解，并不了解Java有沒有實現(xiàn)哪些數(shù)據(jù)結(jié)構(gòu)。但是說在這里想給那些畏難算法與數(shù)據(jù)結(jié)構(gòu)這門課程的人一絲信心，嫑以為非要懂算法和數(shù)據(jù)結(jié)構(gòu)才能編程，不懂這門課程編也能編程，并不是所有的問題都要自己來實現(xiàn)一個數(shù)據(jù)結(jié)構(gòu)。如果因為覺得編程一定要懂算法和數(shù)據(jù)結(jié)構(gòu)，進而對編程產(chǎn)生一種心理陰影，沒有信心，那是很錯誤的！你總需要先用一門語言來練練手，然后才能去學(xué)習(xí)算法和數(shù)據(jù)結(jié)構(gòu)。"懂算法和數(shù)據(jù)結(jié)構(gòu)=會編程"，完全是那些所謂的專家來嚇唬那些新手入門者的，找一本語言介紹書好好練練，編程并不是你想的那么難！）這樣的話，只需要利用提供的數(shù)據(jù)結(jié)構(gòu)存儲需要用的數(shù)據(jù)，然后利用數(shù)據(jù)結(jié)構(gòu)上提供的算法就可以對數(shù)據(jù)進行簡單的處理。鏈表、二叉樹、棧、隊列在JAVA里面統(tǒng)稱為集合，就是把數(shù)據(jù)統(tǒng)統(tǒng)塞進這些集合里面，這些集合的結(jié)構(gòu)可能是不同的。Java集合將這些數(shù)據(jù)結(jié)構(gòu)分成如下幾類。
注意： 這些集合類里面存儲的數(shù)據(jù)都是指向堆內(nèi)存對象的對象棧內(nèi)存變量
區(qū)別：
Java的集合類分為四種：Set，List、Map和Queue四種體系，即MSQL設(shè)計者可以根據(jù)需要使用這四種體系里面的數(shù)據(jù)結(jié)構(gòu)，然后處理數(shù)據(jù)。
Map:代表有映射關(guān)系的集合，也就是key-value這樣的數(shù)據(jù)集合，比如{001——張三，002——李四}
Set：代表無序、不可重復(fù)的集合，比如{1,2,3}。注意：無序、不可重復(fù)
Queue：代表一種隊列集合的實現(xiàn)
List：代表添加時候有序存儲可重復(fù)的集合{1,1,2,3}
1.1 Java集合繼承樹 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
在處理數(shù)據(jù)時候經(jīng)常處理到元素個數(shù)不確定（數(shù)組長度是固定的，初始化后就無法改變），有關(guān)聯(lián)的數(shù)據(jù){001——張三，002——李四}，為了解決這些問題，Java提供了集合類，集合類負責(zé)保存、盛裝這些數(shù)據(jù)，因此集合類也被稱為容器類，所有的集合類都存放在java.util包中
集合類和數(shù)組的區(qū)別：
數(shù)組可以保存基本數(shù)據(jù)類型或者對象，但是集合類智能保存指向堆內(nèi)存數(shù)據(jù)的棧內(nèi)存對象變量（不過很多書上會直接說集合類里面裝的都是對象，這樣可能會好理解一些）。
MSQL接口類的繼承拓撲圖：
提供的四大接口類有如下繼承結(jié)構(gòu)的拓撲圖，Collection和Map是兩個根類，由這兩個根類派生出一系列的接口類。
其中Collection派生SQL，Map派生其他的接口類。MSQL(記法M-SQL，像一種編程語言一樣)：Map，Set，Queue,List這四種集合類最常用的是SML(記法：AI領(lǐng)域的一種語言)，也就是Set，Map，List，這三種接口類最常用實現(xiàn)是，Set的HashSet，Map的HashMap，List的ArrayList，也就是HHA(2HA，2哈——啊哈)如下圖的顏色重的標(biāo)注出來是常用的
?
?
1.2 Collection和Iterator接口 ? ? ? ? ? ? ? ? ? ? ??
1.2.1 Collection 接口
下面如果沒有特別說明，SQL并不指數(shù)據(jù)庫語言SQL，而是代表Set，Queue，List三個Collection的子接口類。
Collection接口下面定義了若干方法，這些方法可以用于SQL三種集合接口類。注意：集合接口模板類里面存儲的是棧對象變量
boolean add(Object o)：該方法用于像一個集合接口類添加一個對象變量o指向的對象，如果添加成功，也就是集合類被改變成功，返回true，否則返回false
boolean addAll(Collection c):假設(shè)調(diào)用該接口的是集合接口類a，調(diào)用該接口后，會將集合接口類c的對象全部添加到集合接口類a中，元素間用逗號隔開
void clear():清空集合里面的所有元素，使元素個數(shù)size為0
boolean contains(Object o):檢測集合里面是否含有對象元素o，有true，無false
boolean containsAll(Collection c):假定調(diào)用該接口的是集合a，那么調(diào)用該接口后會檢測集合a里面是否包含集合c的全部元素，有true，無false
boolean isEmpty()：返回集合是否為空，相當(dāng)于int size()方法返回值為0和不為0的情況
boolean remove(Object o)：刪除集合里面指定元素o，刪除成功返回true，失敗false
boolean removeAll(Collection c)：假設(shè)調(diào)用該接口的是集合a，調(diào)用該接口后，會從集合a里面找出集合c里面沒有的元素，也就是找出差集，如果刪除了一個或一個以上的元素，該方法返回true
boolean retainAll(Collection c):假設(shè)調(diào)用該接口的是集合a，調(diào)用該接口后，刪除a中c沒有的元素，也就是把a編程a和c的交集，如果操作成功，返回true
int size()：返回集合里面元素個數(shù)
Object[] toArray()：把集合轉(zhuǎn)換成一個數(shù)組，所有的集合元素變成對應(yīng)的數(shù)組元素，這樣就可以用數(shù)組的方法來訪問元素
Iterator iterator():返回一個Iterator對象用于遍歷集合里面的所有元素，也就是一個迭代器,這個迭代器可以用于查詢集合類元素，利用System.out的println查詢同樣可以打印出集合的所有數(shù)據(jù)，但是這樣的查詢是不可控制的，也就是說要么查詢出所有，要么不查詢，使用迭代器可以根據(jù)需要進行查詢。
1.2.2 Iterator接口
Iterator接口隱藏了Collection集合類的底層實現(xiàn)，提供了若干方法對Collection集合類進行處理。
方法：
boolean hasNext():如果被迭代的集合仍然有元素沒有被遍歷（迭代），則返回true，就是說如果集合里面迭代一次后剩余的元素不止一個，則返回true。
Object next()：返回集合里下一個元素，注意迭代器每次只返回一個，不像println那樣一次返回所有
void remove():刪除集合里上一次next方法返回的元素，比如說如果等于某個值，就可以刪除這個元素，這樣就可以控制集合返回結(jié)果
看一段代碼：
?
?強烈注意
Iterator接口類僅用于遍歷集合，Iterator本身并不提供盛裝對象的能力，如果需要創(chuàng)建Iterator對象，則必須與有一個可以被它迭代的集合，沒有集合的迭代器沒有存在價值。也就是說Iterator必須依附于Collection對象，有一個Iterator對象，則必然有一個與之關(guān)聯(lián)的Collection對象供其迭代。
代碼倒數(shù)第二行有一個book賦值代碼，但是輸出集合books時候，輸出結(jié)果沒有任何改變，可以得到一個結(jié)論：當(dāng)使用Iterator對集合進行迭代輸出時候，Iterator并沒有指向堆內(nèi)存的集合，而是把集合元素的值傳給了迭代變量，所以修改迭代變量的值對集合元素沒有任何改變。
墻裂注意
1. 刪除集合里面的元素只能通過迭代器的remove方法，也就是it.remove()才可以刪除集合里面的元素，通過調(diào)用集合自身的方法來刪除集合元素值也就是說books.remove(book)將會出錯，引發(fā)的異常是java.util.ConcurrentModificationException異常，或者簡單的說，迭代過程中，不能通過除了迭代器之外的方式來修改集合，也就是說在迭代過程中，只有迭代器有修改集合的權(quán)限，其他方式包括集合本身都沒有修改集合自身元素的權(quán)限。（其實更本質(zhì)的是集合類變量本身只是指向堆內(nèi)存的數(shù)據(jù)，迭代時候，相當(dāng)于堆內(nèi)存的使用權(quán)交給了迭代器，集合類本身當(dāng)然沒有修改權(quán)限）迭代器采用的是快速失敗機制，一旦在迭代過程中，檢測到該集合已經(jīng)被修改（通常是其他線程修改），程序立即引發(fā)ConcurrentModificationException異常，而不是顯示修改后的結(jié)果，這樣可以避免共享資源而引發(fā)的潛在問題。
第二for循環(huán)遍歷集合元素
前面已經(jīng)介紹了for循環(huán)有兩種方是，一種是標(biāo)準(zhǔn)的，另一種是被很多書稱之為foreach循環(huán)（這種叫法很容易讓人誤解循環(huán)的關(guān)鍵字是foreach，但其實依然是for），這里我稱之為第二for循環(huán)（表示第二種for循環(huán)），同樣使用在用for循環(huán)迭代輸出集合類“中”也不能修改集合元素。同樣使用該種循環(huán)方式按照前面的語法
for（循環(huán)變量類型 循環(huán)變量：集合類）
代碼如下:
1 //創(chuàng)建一個集合 2 Collection lan = new HashSet(); 3 //往集合里面裝東西 4 lan.add("Englis"); 5 lan.add("Chinese"); 6 lan.add("Castellano"); 7 lan.add("Deutsch"); 8 //使用第二for循環(huán)輸出集合里面的元素 9 for(Object lang:lan){ 10 String lgu = (String)lang;//集合里面存儲的都是對象變量 11 System.out.print(lgu); 12 }2 Set集合類 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ??
Set集合特點：Set集合接口類的元素特征是無序、不重復(fù)
Set集合與Collection基本完全一樣，它沒有提供任何額外的方法，實際上Set就是Collection，只是行為不同（Set不允許重復(fù)元素）。
Set不允許重復(fù)元素，如果相同元素加入同一個Set集合中則會添加失敗，判斷是否相同的標(biāo)準(zhǔn)是使用equals方法，而不是==方法，所以比較嚴(yán)格。
例如：
1 Set books = new HashSet(); 2 books.add(new String("English")); 3 //再次添加一個不同的對象 4 books.add(new String("English"));由于Set是一個集合類，集合類里面應(yīng)該裝的是不同對象，上述代碼里面明顯裝的是不同對象，但是Set集合判斷是否是同一個對象的標(biāo)準(zhǔn)是equals方法，所以不能添加（有點怪怪的）
上面介紹的是Set集合的通用知識，因此完全適合后面介紹的HashSet、TreeSet、EnumSet三個實現(xiàn)類，只是三個實現(xiàn)類各有特色。
2.1 HashSet——LinkedHashSet類 ? ??
2.1.1 HashSet接口 ? ? ? ? ? ? ? ? ? ??
HashSet是Set接口的典型實現(xiàn)，大多數(shù)時候使用Set集合就是使用這個實現(xiàn)類，HashSet按Hash算法存儲集合中的元素，因此具有很好的存取和查找性能。
HashSet特點
1. 不能保證元素的排列順序，順序有可能發(fā)送變化
2. HashSet不是同步的，如果多個線程同時訪問一個Set集合或者一個HashSet，當(dāng)2條或2條以上的線程同時修改了HashSet集合時，必須通過代碼來保證同步。
3. 集合元素值可以是null
當(dāng)向HashSet集合中存入一個元素，HashSet會調(diào)用該對象的hashCode()方法來得到該對象的hashCode值，然后根據(jù)hashCode值來決定該對象在HashSet中存儲位置。如果有兩個元素通過equals方法比較返回true，但他們的hashCode()方法返回值不相等，HashSet會把他們存儲在不同位置，也就可以添加成功。
簡單的說：HashSet集合通過兩個條件來判斷是否存儲要插入的元素。一個是通過equals判斷元素值是否相等，另一個是通過hashCode（）方法判斷Hash值是否相等。只有兩個都相等了，才說明要插入的元素相等。
上面的程序中向books集合中添加了2個A對象、2個B對象、2個C對象，其中C類重寫了equals()方法，總是返回true，hashCode()方法總是返回2，這將導(dǎo)致HashSet會把2個C對象當(dāng)成同一個對象。運行上述可以得到
[B@1,B@1,C@2,A@343,A@kd33]
需要注意的是
如果需要把一個對象放入HashSet中時，如果重寫該對象對應(yīng)類的equals()方法，也應(yīng)該重寫起hashCode()方法，其規(guī)則是：如果2個對象通過equals方法比較返回true，這兩個hashCode應(yīng)該也相同，這樣就不會添加兩個同樣的對象。
如果兩個對象通過equals方法返回true，但是通過hashCode返回不同的，那么將會將兩個對象保存在不同位置，從而都可以添加成功，這樣會違反Set集合的特征（雖然可以添加成功）。
如果equals方法返回false，但hashCode值卻是一樣的，這樣更加極品。因為hash值一樣，HashSet試圖把它們保存在同一個位置（但實際不能這樣做，否認則將覆蓋其中一個），所以處理比較復(fù)雜，而且HashSet訪問元素根據(jù)hash值訪問，如果HashSet中包含元素有相同的hashCode值，將導(dǎo)致性能下降。
HashSet的使用hashCode值去查詢元素，hashCode就相當(dāng)于數(shù)組索引，但為什么不使用數(shù)組呢？因為數(shù)組元素索引是連續(xù)的，并且長度固定，無法自由增加數(shù)組長度。而HashSet訪問元素，可以先算出hashCode值，然后去對應(yīng)位置取出元素。
?重寫hashCode方法原則：
?當(dāng)兩個對象通過equals方法返回true時，對象的hashCode應(yīng)該也要相等
?對象中用作equals比較標(biāo)準(zhǔn)的熟悉，都應(yīng)該用來計算hashCode值
?重寫hashCode()方式
?第一步：
?對象內(nèi)每個有意義的熟悉f（即每個用作equals()比較標(biāo)準(zhǔn)的屬性）計算出一個int類型的hashCode值，計算方法如下：
?不同類型屬性取得hashCode值方式
?屬性類型??????計算方式
?boolean???????hashCode=(f?0:1);
?整數(shù)類型(byte,short,char,int)?hashCode=(int)f;
?long???????hashCode=(int)(f^(f>>>32))
?float???????hashCode=Float.floatToIntBits(f)
?double???????long l = Double.doubleTolongBits(f);
?hashCode = (int)(l^(l>>>32));
?普通引用類型?????hashCode = f.hashCode();
第二步：
用第一步計算出來的對象的多個hashCode值組合計算出一個最終的hashCode，作為對象的hashCode值返回
return f2.hashCode() + (int)f2;
為了避免直接相加產(chǎn)生的偶然相等(兩個對象的f1、f2不等，但他們的和剛好相等。例如6=2+4=3+3)，可以通過為各屬性乘以一個質(zhì)數(shù)再相加：
return f1.hashCode()*17 + (int)f2*13;
當(dāng)向HashSet中添加可變對象時，必須十分小心，如果修改HashSet集合中的對象，有可能導(dǎo)致該對象與集合中其他對象相等，從而導(dǎo)致HashSet無法準(zhǔn)確訪問對象。也就是說添加時候會做出檢查，修改時候是不會檢查元素之間是否相同的。所以如果修改導(dǎo)致了與其他對象相等，那么HashSet無法準(zhǔn)確訪問該對象。
2.1.2 LinkedHashSet接口 ? ? ? ? ? ? ? ? ??
HashSet還有一個子類LinkedHashSet集合，LinkedHashSet集合也是根據(jù)元素hashCode值來決定元素的存儲位置，但它同時使用鏈表維護元素次序，這樣時元素看起來以插入的順序保存的，也就是說，當(dāng)遍歷LinkedHashSet集合元素時，HashSet將會按元素添加順序來訪問集合里的元素。LinkedHashSet需要維護元素的插入順序，因此性能略低于HashSet性能，但迭代輸出時候性能將會很好。
?注意：LinkedHashSet集合特點是有序的，并且順序和添加時候順序一致。
?2.2 SortedSet——TreeSet接口 ? ? ? ??
TreeSet是SortedSet接口的唯一實現(xiàn)，正如SortedSet名字所述，TreeSet可以確保元素處于排序狀態(tài)。TreeSet提供了如下方法
方法：?????????????
Comparator comparator():返回當(dāng)前Set使用的Comparator，或者null（表示自然方式排序）
Object first():返回集合中的第一個元素
Object last():返回集合中的最后一個元素
Object lower(Object e):返回集合中與e相比的最大元素，e不一定是TreeSet里面的元素，也就是下確界
Object higher(Object e):返回集合中與e相比的最小元素，也就是上確界，e不一定是TreeSet里面的元素
SortedSet subSet(fromElement,toElement):返回此Set的子集合，范圍從fromElement(包含)到toElement(不包含)
SortedSet headSet（toElement）:返回此Set的子集，由小于toElement的元素組成
SortedSet tailSet(fromElement):返回此Set的子集，由大于等于fromElement的元素組成
總的來說：TreeSet提供了：訪問第一個最后一個，上確界、下確界（前一個后一個），以及截取子TreeSet的方法
區(qū)別：????
同樣是提供了排序的存儲，LinkedHashSet與TreeSet是有本質(zhì)區(qū)別的。LinkedHashSet的順序是插入元素時候的順序，TreeSet提供的是元素值的順序
TreeSet支持兩種排序方法：自然排序和定制排序，默認是自然排序
2.2.1 自然排序 ? ? ?
TreeSet會調(diào)用集合元素的compareTo(Object obj)方法來比較元素之間大小關(guān)系，然后集合元素按照升序排列，這種方式就是自然排序。
Java提供了一個Comparable接口，該接口定義一個compareTo(Object obj)方法，該方法返回一個整數(shù)值，實現(xiàn)該接口的類必須實現(xiàn)該方法，實現(xiàn)了該接口的類的對象就可以比較大小。當(dāng)一個對象調(diào)用該方法與另一個對象進行比較，例如obj1.compareTo(obj2)，如果該方法返回0，則表示這兩個對象相等；如果返回一個正整數(shù)，則表明obj1大于obj2，如果返回是一個負整數(shù)，則表示obj1小于obj2。
Java的一些常用類已經(jīng)實現(xiàn)了Comparable接口，并提供了比較大小的標(biāo)準(zhǔn)。下面是實現(xiàn)了Comparable接口的常用類。
BigDecimal、BigInteger以及所有數(shù)值型對應(yīng)的包裝類：按它們對應(yīng)的數(shù)值大小進行比較
Character：按字符的UNICODE值進行比較
Boolean：true對應(yīng)的包裝類實例大于false對應(yīng)的包裝類實例
String：按字符串字符的UNICODE值進行比較
Date、Time：后面的時間、日期比前面的時間、日期大。
如果試圖把一個對象添加進TreeSet時，該對象的類必須實現(xiàn)Comparable接口，否則程序拋出異常。另外在實現(xiàn)compareTo(Object obj)方法時，需要將被比較對象obj強制類型轉(zhuǎn)換成相同類型，因為只有相同類的實例才會比較大小。比如日期和字符串就不能直接比較。
對TreeSet集合而言：判斷兩個對象不相等的標(biāo)準(zhǔn)是：兩個對象通過equals方法比較false，或通過compareTo(Object obj)比較沒有返回0——即使兩個對象是同一個對象。
類似地：當(dāng)需要把一個對象放入TreeSet中時，重寫該對象對應(yīng)類的equals()方法時，應(yīng)該保證該方法與compareTo(Object obj)方法有一致的結(jié)果，其規(guī)則是：如果兩個對象通過equals方法比較返回true時，這兩個對象通過compareTo(Object obj)方法比較返回0.
如果兩個對象通過equals方法返回true，但是通過compareTo(Object obj)返回不同的，那么將會將兩個對象保存在不同位置，從而都可以添加成功，這樣會違反Set集合的特征（雖然可以添加成功）。
如果equals方法返回false，但compareTo(Object obj)值卻是一樣的，這樣更加極品。因為比較相等，TreeSet試圖把它們保存在同一個位置（但實際不能這樣做，否認則將覆蓋其中一個），所以處理比較復(fù)雜。
如果向TreeSet中添加一個可變對象后，并且后面程序修改了該可變 對象的屬性，導(dǎo)致它與其他對象的大小順序發(fā)生了改變，但TreeSet不會再次調(diào)整它們的順序，甚至可能導(dǎo)致TreeSet中保存這兩個對象，它們通過equals方法比較返回true，通過compareTo(Object obj)方法比較返回0.
2.2.2 定制排序 ? ? ??
可以對TreeSet集合類進行自定義排序，比如降序。可以使用Comparator接口幫助，該接口里面有一個int compare(T o1,T o2)方法用于比較o1和o2大小，比較原理痛compareTo()一樣。
如果實現(xiàn)定制排序，需要在創(chuàng)建TreeSet集合對象時，提供一個Comparator對象與該TreeSet集合關(guān)聯(lián)，由該Comparator對象負責(zé)集合元素的排序邏輯。
2.3 EnumSet類 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ??
EnumSet是一個專為枚舉類設(shè)計的集合類，EnumSet中所有值都必須是指定枚舉類型的枚舉值，該枚舉類型在創(chuàng)建EnumSet時顯式或隱式地指定。EnumSet集合元素也是有序的，EnumSet以枚舉值在Enum類定義順序來決定集合元素的順序。也就是不以元素值大小決定，根據(jù)添加順序決定。
EnumSet在內(nèi)部以為向量的形式存儲，這種存儲形式緊湊、高效，占用內(nèi)存小。
EnumSet集合不允許加入null元素，如果插入null元素將拋出空指針異常。如果只是測試是否出現(xiàn)null元素或刪除null元素都不會拋出異常，只是刪除操作將返回false，因為沒有任何null元素被刪除。
? EnumSet類沒有暴露任何構(gòu)造器來創(chuàng)建該類的實例，程序應(yīng)該通過它提供的static方法來創(chuàng)建EnumSet對象。它提供了如下常用static方法來創(chuàng)建EnumSet對象。
2.3.1 EnumSet創(chuàng)建方法 ? ? ? ? ??
static EnumSet allOf(Class elementType):創(chuàng)建一個包含指定枚舉類里所有枚舉值的EnumSet集合
static EnumSet complementOf(EnumSet s):假設(shè)調(diào)用該方法的是EnumSet a，調(diào)用后的新EnumSet的集合元素是a+s，結(jié)果放在a中
static EnumSet copyOf(Collection c):使用一個普通集合來創(chuàng)建EnumSet集合
static EnumSet copyOf(EnumSet s):創(chuàng)建一個與指定EnumSet具有相同元素類型、相同集合元素的EnumSet
static EnumSet noneOf(Class elementType):創(chuàng)建一個元素類型為指定枚舉類型的空EnumSet
static EnumSet of(E first,E...rest):創(chuàng)建一個包含一個或多個枚舉值的EnumSet，傳入的多個枚舉值必須屬于同一個枚舉類。
static EnumSet range(E from ,E to):創(chuàng)建包含從from枚舉值，到to枚舉值范圍內(nèi)所有枚舉值的EnumSet集合
注意：
EnumSet復(fù)制另一個EnumSet集合中所有元素創(chuàng)建新的EnumSet，或復(fù)制另一個Collection集合中所有元素來創(chuàng)建新的EnumSet，當(dāng)復(fù)制Collection集合中所有元素創(chuàng)建新的EnumSet時，要求Collection集合中所有元素必須是同一個枚舉類型的枚舉值
HashSet和TreeSet是Set的兩個典型實現(xiàn)，那如何選擇HashSet和TreeSet呢？HashSet的性能總是比TreeSet好（特別是最常用的添加、查詢元素等操作），因為TreeSet需要額外的紅黑樹算法來維護集合元素的次序。只有當(dāng)需要一個保持排序的Set時，才應(yīng)該使用TreeSet，否則都應(yīng)該使用HashSet
HashSet還有一個子類：LinkedHashSet，對于普通插入、刪除操作，LinkedHashSet比HashSet要略慢一點：這是有維護鏈表所帶來的額外開銷，不過有了鏈表，遍歷LinkedHashSet會更快
EnumSet是所有Set實現(xiàn)類中性能最好的，但它只能保存同一個枚舉類的枚舉值作為集合元素。
必須指出的是，Set的三個實現(xiàn)類HashSet、TreeSet和EnumSet都是線程不安全的，如果有多條線程同時訪問一個Set集合，并且有超過一條線程修改了該Set集合，則必須手動保證該Set集合的同步性。通常可以通過Collections工具類synchronizedSortedSet方法來包裝該Set集合。次操作最好在創(chuàng)建時進行，以防止對Set集合的意外非同步訪問。
3.Queue集合類 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
?
3.1概述 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
Queue用于模擬了隊列這種數(shù)據(jù)結(jié)構(gòu)，隊列是指"先進先出"(FIFO)的容器。隊列的頭部保存在隊列中時間最長的元素，隊列的尾部保存在隊列中時間最短的元素。
3.2隊列 ? ? ? ? ? ? ? ? ? ? ? ? ? ??
隊列是一種特殊的線性表，它只允許在表的前端（front）進行刪除操作，而在表的后端（rear）進行插入操作。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。隊列中沒有元素時，稱為空隊列。
在隊列這種數(shù)據(jù)結(jié)構(gòu)中，最先插入的元素將是最先被刪除的元素；反之最后插入的元素將是最后被刪除的元素，因此隊列又稱為“先進先出”（FIFO—first in first out）的線性表。
隊列空的條件：front=rear
隊列滿的條件： rear = MAXSIZE
隊列不允許隨機訪問隊列中的元素。
3.3 Queue接口定義的方法 ? ? ? ? ? ? ? ?
void add(Object e)：將制定元素加入此隊列的尾部。
Object element()：獲取隊列頭部的元素，但是不刪除該元素。
boolean offer(Object e):將指定元素加入此隊列的尾部。當(dāng)使用有容量限制的隊列時，此方法通常比add(Object e)方法更好。
Object peek()：獲取隊列頭部的元素，但是不刪除該元素，如果此隊列為空，則返回null
Object poll()：獲取隊列頭部的元素，并刪除該元素，如果隊列為空，則返回為null
Object remove()：獲取隊列頭部的元素，并刪除該元素。
3.4 Queue的實現(xiàn)類 ? ? ? ? ? ? ? ? ? ? ? ? ?
Queue有兩個常用的實現(xiàn)類：LinkedList和PriorityQueue，下面介紹著兩個類。
3.4.1 LinkedList實現(xiàn)類 ? ?
LinkedList類是一個奇怪的類，它是List接口的實現(xiàn)類——這意味著它是一個List集合，可以根據(jù)索引來隨機訪問集合中的元素。除此之外，LinkedList還實現(xiàn)了Deque接口，Deque接口是Queue接口的子接口，它代表一個雙向隊列，Deque有如下方法。
void addFirst(Object e)：將制定元素插入該雙向隊列的開頭
void addLast(Object e):將制定元素插入該雙向隊列的末尾
Iterator descendingIterator()：返回以該雙向隊列對應(yīng)的迭代器，該迭代器將以逆向順序來迭代隊列中的元素。
Object getFirst()：獲取、但不刪除雙向隊列的第一個元素
Object getLast()：獲取、但不刪除雙向隊列的最后一個元素
boolean offerFirst(Object e)：將指定的元素插入該雙向隊列的開頭
boolean offerLast(Object e):將指定的元素插入該雙向隊列的末尾
Object poolFirst()：獲取、并刪除該雙向隊列的第一個元素；如果此雙向隊列為空，則返回null
Object poolLast()：獲取、并刪除該雙向隊列的最后一個元素；如果此雙向隊列為空，則返回null
Object peekFirst()：獲取、但不刪除該雙向隊列的第一個元素；如果此雙向隊列為空，則返回null
Object peekLast()：獲取、但不刪除該雙向隊列的最后一個元素；如果此雙向隊列為空，則返回null
Object pop()：pop出該雙向隊列所表示的棧中第一個元素
void push(Object e)：將一個元素push進該雙向隊列所表示的棧中(即該雙向隊列的頭部)
Object removeFirst()：獲取并刪除該雙向隊列的第一個元素
Object removeFirstOccurrence(Object o)：刪除該雙向隊列的第一次出現(xiàn)元素o
removeLast()：獲取并刪除該雙向隊列的最后一個元素
removeLastOccurrence(Object o)：刪除該雙向隊列的最后一次出現(xiàn)的元素o
LinkedList不僅可以當(dāng)成雙向隊列使用，也可以當(dāng)成"棧"(但其實不是棧)使用，因為該類里面有pop和push兩個方法，除此之外，LinkedList實現(xiàn)了List接口，所以被當(dāng)成List使用。
LinkedList有上述方法讓它可以當(dāng)做雙向隊列、棧和List集合用。LinkedList是個相當(dāng)強大的集合類。
LinkedList與ArrayList、Vector的實現(xiàn)機制完全不同，ArrayList、Vector內(nèi)部以數(shù)組形式保存集合中的元素，因此隨機訪問集合元素上性能較好,而LinkedList以鏈表形式保存集合，所以隨機訪問集合元素較差，但插入、刪除元素時性能出色。
通常編程時候無需理會ArrayList和LinkedList性能差異，只需要知道LinkedList集合不僅提供了List功能，還有雙向隊列及棧功能，在一些性能比較敏感的地方，可能需要慎重選擇哪個List實現(xiàn)。下面是三者性能差異：
類別 實現(xiàn)機制 隨機訪問排名 迭代排名 插入排名 刪除排名
數(shù)組 連續(xù)內(nèi)存區(qū)保存元素 1 ?不支持 不支持 不支持
ArrayList 內(nèi)部以數(shù)組保存元素 ?2 2 ?2 2
Vector 內(nèi)部以數(shù)組保存元素 3 3 ? ?3 3
LinkedList 內(nèi)部以鏈表保存元素 ?4 ?1 ? 1 1
從上表看出：因為數(shù)組以一塊連續(xù)內(nèi)存區(qū)保存所有數(shù)組元素，所以數(shù)組在隨機訪問時性能最好。所有內(nèi)部數(shù)組作為底層實現(xiàn)的集合在隨機訪問時也有較好的性能；而內(nèi)部以鏈表作為底層實現(xiàn)的集合在插入、刪除操作時有很好的性能，以鏈表作為底層實現(xiàn)的集合也比數(shù)組作為底層實現(xiàn)的集合性能好。
多次運行上面程序會發(fā)現(xiàn)，迭代ArrayList集合的時間略大于迭代LinkedList集合的時間。因此，關(guān)于使用List集合有如下建議：
如果需要遍歷List集合元素，對于ArrayList、Vector集合，則應(yīng)該使用隨機訪問方法(get)來遍歷集合元素，這樣性能更好。對于LinkedList集合，則應(yīng)該采用迭代器來遍歷集合元素
如果需要經(jīng)常執(zhí)行插入、刪除操作來改變List集合的大小，則應(yīng)該使用LinkedList集合，而不是ArrayList。使用ArrayList、Vector集合將需要經(jīng)常重新分配內(nèi)部數(shù)組的大小，其時間開銷常常是使用LinkedList時時間開銷的幾十倍，效果很差。
如果有多條線程需要同時訪問List集合中元素，可以考慮使用Vector這個同步實現(xiàn)。
3.4.2 PriorityQueue實現(xiàn)類 ? ?
PriorityQueue是一個比較標(biāo)準(zhǔn)的隊列實現(xiàn)類，之所以說它是比較標(biāo)準(zhǔn)的隊列實現(xiàn)，而不是絕對標(biāo)準(zhǔn)的隊列實現(xiàn)是因為：PriorityQueue保存隊列元素的順序并不是按加入隊列的順序，而是按隊列元素的大小進行重新排序。因此因此當(dāng)調(diào)用peek方法或者poll方法來取出隊列中的元素時，并不是取出最先進入隊列的元素，而是取出隊列最小的元素。從這個意義上看,PriorityQueue已經(jīng)違反了隊列的最基本的規(guī)則：先進先出。
PriorityQueue不允許插入null元素，它還需要對隊列元素進行排序，隊列元素有兩種排序方式：
自然排序：采用自然順序的PriorityQueue集合中的元素必須實現(xiàn)了Comparable接口，而且應(yīng)該是同一類的多個實例，否則可能導(dǎo)致ClassCastException異常
定制排序：創(chuàng)建PriorityQueue隊列時，傳入一個Comparator對象，該對象負責(zé)對隊列中所有元素排序，采用定制排序時不要求隊列元素實現(xiàn)Comparable接口
PriorityQueue隊列對元素的要求與前面TreeSet對元素的要求基本一致，可以參考TreeSet處理
4.List接口和ListIterator接口 ? ? ? ? ? ? ? ? ? ? ? ? ? ??
List作為Collection接口的子接口，可以使用Collection接口里的全部方法，而且List是有序集合，因此List集合里面增加了一些根據(jù)索引來操作集合元素的方法：
void add(int index,Object element)：將元素element插入在List集合index處
boolean addAll(int index,Collection c):將集合c的所有元素都插入在List集合index處
Object get(int index):返回集合index索引處的元素
int indexOf(Object o):返回對象o在List集合中出現(xiàn)的位置索引
int lastIndexOf(Object o):返回對象o在List集合中最后一次出現(xiàn)的位置索引
Object remove(int index):刪除并返回index索引處的元素
Object set(int index ,Object element):將index索引處的元素替換成element對象，返回新元素
List subList(int fromIndex,int toIndex):返回從索引fromIndex(包含)到索引toIndex(不包含)處所有集合元素的子集合。
所有List實現(xiàn)類都可以調(diào)用這些方法實現(xiàn)對集合元素的操作，相對于Set集合，List可以根據(jù)索引來插入、替換和刪除集合元素。
與Set只提供了一個iterator()方法不同，List還額外提供了一個listIterator()方法，該方法返回一個ListIterator對象，ListIterator接口繼承了Iterator接口，提供了專門操作List的方法。
ListIterator接口在Iterator接口基礎(chǔ)上增加了如下方法：
boolean hasPrevious():返回該迭代器關(guān)聯(lián)的集合是否還有上一個元素
Object previous()：返回該迭代器的上一個元素
void add()：在指定位置插入一個元素
拿ListIterator與普通Iterator進行對比，容易發(fā)現(xiàn)ListIterator增加了向前迭代的功能(Iterator只能向后迭代),而且ListIterator還可以通過add方法向List集合添加元素(Iterator只能刪除元素)。
正向迭代是從正向迭代輸出元素，反向迭代是從反向迭代輸出元素。
4.1 ArrayList和Vector實現(xiàn)類 ? ? ? ? ??
ArrayList和Vector是List的兩個典型實現(xiàn)類，完全支持List接口的全部功能。
ArrayList和Vector類是基于數(shù)組實現(xiàn)的List類，所以ArrayList和Vector類封裝了一個動態(tài)再分配的Object[]數(shù)組。每個ArrayList或Vector對象有一個capacity屬性，這個capacity表示它們所封裝的Object[]數(shù)組長度。當(dāng)想ArrayList或Vector中添加元素時，其capacity會自動增加。
通常無需關(guān)心ArrayList或Vector的capacity屬性，但如果想ArrayList集合或Vector集合中添加大量元素時，可以使用ensureCapacity方法一次性增加capacity，可以減少增加分配次數(shù)，提高性能。
如果開始就知道ArrayList集合或Vector集合需要保存多少個元素，可以創(chuàng)建時候就指定capacity大小。如果不指定，則capacity屬性默認值為10
此外，ArrayList和Vector集合提供了兩個方法操作capacity屬性。
void ensureCapacity(int minCapacity)：將ArrayList或Vector集合中的capacity增加minCapacity
void trimToSize()：調(diào)整ArrayList或Vector集合的capacity為列表當(dāng)前大小。程序可調(diào)用該方法來減少ArrayList或Vector集合對象存儲空間
ArrayList或Vector在用法上幾乎完全相同，但Vector是一個古老的集合最開始Java沒有提供系統(tǒng)的集合框架，所以Vector提供了一些方法名很長的方法。 ArrayList開始就作為List的主要實現(xiàn)類，因此沒有那些方法名很長的方法，實際上Vector有很多缺點，通常盡量少用Vector實現(xiàn)類。
ArrayList和Vector的顯著區(qū)別是ArrayList是線程不安全的，當(dāng)多線程訪問同一個ArrayList集合時，如果超過一條修改了ArrayList集合，則需要手動保證集合的同步性，而Vector集合是線程安全的，無需保證集合的同步性。Vector性能低于ArrayList性能。
Vector還提供了Stack子類，用于模擬"棧"這種數(shù)據(jù)結(jié)構(gòu)，棧通常是后進先出進棧出棧的都是Object，所以取出棧里的元素需要做類型轉(zhuǎn)換。
Object peek()：返回"棧"的第一個元素，但并不將該元素pop出棧
Object pop():返回棧的第一個元素，并將該元素pop出棧
void push(Object item):將一個元素push進棧，最后一個進棧的元素總是位于棧頂。
數(shù)組的工具類Arrays里面提供了asList(Object...a)方法，該方法可以把一個數(shù)組或指定個數(shù)的對象轉(zhuǎn)換成一個List集合，這個List集合既不是ArrayList實現(xiàn)類，也不是Vector實現(xiàn)類的實例，而是Arrays的內(nèi)部類ArrayList的實例
Arrays.ArrayList是一個固定長度的List集合，程序只能遍歷訪問該集合里的元素，不可增加、刪除集合里的元素。
5.Map集合????????????????????????????????????????????????????????????????????????
5.1 Map集合特點?????????????????
Map用于保存具有映射關(guān)系的數(shù)據(jù)，因此Map集合保存著兩組值，一組值用于保存Map里的key，另外一組值用于保存Map里的value，key和value都可以是任何引用類型的數(shù)據(jù)。Map的key不允許重復(fù)，即同一個Map對象的任何兩個key通過equals方法比較總是返回false。key和value之間存在單向一對一關(guān)系，即通過指定的key，總能找到唯一的、確定的value。從Map中取出數(shù)據(jù)時，只要給出指定的key，就可以取出對應(yīng)的value。也就是說Map保存的元素是鍵值對。如果把Map里的key放在一起看，它們就組成了一個Set集合(key是沒有順序，key與key之間不能重復(fù))，事實上Map確實包含了一個keySet()方法，用于返回Map所有key組成的Set集合。
不僅如此Map里key集合和Set集合里元素的存儲形式也很像，Map子類和Set子類在名字上也幾乎相似。Set接口下有HashSet、LinkedHashSet、SortedSet(接口)、TreeSet、EnumSet等實現(xiàn)類和子接口，而Map接口下則有HashMap、LinkedHashMap、SortedMap(接口)、TreeMap、EnumMap等實現(xiàn)類和子接口。正如名字暗示，Map的實現(xiàn)類和子接口中key集存儲形式和對應(yīng)的Set集合存儲形式完全相同。如果把Map所有的value放在一起看，它們非常類似于一個List：元素與元素之間可以重復(fù)，每個元素通過索引來查找，只是Map中的索引不再使用整數(shù)值，而是另一個對象來作為索引。如果需要從List集合取出元素，需要提供該元素的數(shù)字索引，如果需要從Map中取出元素，需要提供該元素的key索引，因此Map也被稱為字典或關(guān)聯(lián)數(shù)組。
5.2 Map接口方法???????????????????
Map中包括一個內(nèi)部實現(xiàn)類：Entry。該類封裝了一個key-value對，Entry包含三個方法：
Object getKey():返回該Entry里包含的key值
Object getValue()：返回Entry里面包含的value值
Object setValue(V value)：設(shè)置該Entry里包含的value值，并返回新設(shè)置的value值
可以把Map理解成一個特殊的Set，只是該Set里包含的集合元素是Entry類對象，而不是普通對象
5.3Map接口的內(nèi)部實現(xiàn)類??????
Map中包括一個內(nèi)部實現(xiàn)類：Entry。該類封裝了一個key-value對，Entry包含三個方法： Object getKey():返回該Entry里包含的key值 Object getValue()：返回Entry里面包含的value值 Object setValue(V value)：設(shè)置該Entry里包含的value值，并返回新設(shè)置的value值 可以把Map理解成一個特殊的Set，只是該Set里包含的集合元素是Entry類對象，而不是普通對象
5.4?HashMap和Hashtable
HashMap和Hashtable是Map接口的典型實現(xiàn)類，它們之間的關(guān)系類似于ArrayList和Vector關(guān)系：Hashtable是個古老的Map實現(xiàn)類，它有兩個繁瑣的方法elements()和keys()，現(xiàn)在基本不用了。
Hashtable和HashMap的區(qū)別
Hashtable是一個線程安全的Map實現(xiàn)，但HashMap是線程不安全的實現(xiàn)，所以HashMap比Hashtable性能好，但多線程訪問Map對象時，Hashtable實現(xiàn)類更好 Hashtable不允許使用null作為key和table，如果把null值放進Hashtable中，將會引發(fā)NullPointerException異常，但HashMap可以使用null作為key或value，但由于key不能重復(fù)，所以HashMap里最多只有一項key-value對的key為null，但可以有無數(shù)多項key-value對的value為null。key類似Set集合的，所以無序、禁止重復(fù)key，而value類似List所以可以重復(fù)，順序和key是對應(yīng)的。 代碼：
1 package chapter7; 2 3 import java.util.HashMap; 4 5 public class NullInHashMapTest { 6 public static void main(String[] args){ 7 HashMap hm = new HashMap(); 8 //將兩個key值為null的放在key-value鍵值對中 9 hm.put(null, null); 10 hm.put(null, null); 11 //將一個value值為null的放入key-value鍵值對中 12 hm.put('a', null); 13 System.out.println(hm); 14 } 15 } 16 17 輸出結(jié)果：{null=null, a=null}根據(jù)輸出結(jié)果可以看出HashMap重寫了toString()方法，實際所有Map實現(xiàn)類都重寫了toString()方法，調(diào)用Map對象的toString()方法總是返回如下格式字符串 {key1=value1,key2=value2}
Hashtable從類名上就可以看出是一個古老的類，命名甚至都沒有遵守Java的命名規(guī)范：每個類的單詞首字母大寫。后來也沒有改成HashTable，否則將有大量程序需要改寫。盡量少用Hashtable類，即使需要創(chuàng)建線程安全的Map實現(xiàn)類，可以通過Collections工具類，把HashMap變成線程安全的，無須使用Hashtable實現(xiàn)類。
為了成功在HashMap、Hashtable中存儲、獲取對象，用作key的對象必須實現(xiàn)hashCode方法和equals方法。HashMap、Hashtable判斷兩個key相等的標(biāo)準(zhǔn)也是key通過equals方法返回true，兩個key的hashCode相等。判斷value相等的標(biāo)準(zhǔn)是equals返回true即可，不需要hashCode判斷。
1 package chapter7; 2 3 import java.util.Hashtable; 4 5 //定義類A，該類根據(jù)A對象的count屬性來判斷兩個對象是否相等，計算hashCode值 6 //只要兩個A對象的count相等，則它們通過equals比較也相等，其hashCode值也相等 7 8 class AA{ 9 int count; 10 public AA(int count){ 11 this.count = count; 12 } 13 public boolean equals(Object obj){ 14 if (obj == this){ 15 return true; 16 } 17 if(obj!=null && obj.getClass() == AA.class){ 18 AA a = (AA)obj; 19 if(this.count == a.count){ 20 return true; 21 } 22 23 } 24 return false; 25 } 26 public int hashCode(){ 27 return this.count; 28 } 29 } 30 //定義類B，B對象與任何對象通過equals方法比較都相等 31 class BB{ 32 public boolean equals(Object obj){ 33 return true; 34 } 35 } 36 public class HashtableTest { 37 public static void main(String[] args){ 38 Hashtable ht = new Hashtable(); 39 ht.put(new AA(60000),"English"); 40 ht.put(new AA(87653),"Castellano"); 41 ht.put(new AA(1232),new B()); 42 System.out.println(ht); 43 //只要兩個對象通過equals比較返回true，Hashtable就認為它們是相等的value。 44 //因為Hashtable中有一個B對象，它與任何對象通過equals比較都相等，所以下面輸出true。 45 System.out.println(ht.containsValue("測試字符串")); 46 //只要兩個A對象的count屬性相等，它們通過equals比較返回true，且hashCode相等 47 //Hashtable即認為它們是相同的key，所以下面輸出true。 48 System.out.println(ht.containsKey(new AA(87653))); 49 //下面語句可以刪除最后一個key-value對 50 ht.remove(new AA(1232)); 51 for(Object key:ht.keySet()){ 52 System.out.print(key + "---->"); 53 System.out.print(ht.get(key) + "\n"); 54 } 55 } 56 }程序最后展示了如何遍歷Map中的全部key-value對：調(diào)用Map對象的keySet方法返回全部key組成的Set對象，通過遍歷Set的元素(就是Map的全部key)就可以遍歷Map中的所有鍵值對。
與HashSet類似的是，盡量不要使用可變對象作為HashMap、Hashtable的key，如果確實需要使用可變對象作為HashMap、Hashtable的key，則盡量不要在程序中修改作為key的可變對象。
HashSet有一個子類是LinkedHashSet，HashMap則有一個子類：LinkedHashMap；LinkedHashMap也使用雙向鏈表來維護key-value對的次序，該鏈表定義了迭代次序，迭代順序與插入順序時候保持一致。
LinkedHashMap可以避免需要對HashMap、Hashtable里的key-value對進行排序(只要插入key-value對時保持順序即可)。同時可以避免使用TreeMap所增加的成本。LinkedHashMap需要維護元素的插入順序，因此性能略低于HashMap的性能，但在迭代訪問Map里的全部元素時將有很好的性能，因為它以鏈表來維護內(nèi)部順序。下面程序示范了LinkedHashMap的功能：迭代輸出LinkedHashMap的元素時，將會按添加key-value對相同順序輸出。
Properties類???????????????????????????
Properties類是Hashtable類的子類，該文件處理屬性文件(ini文件就是一種屬性文件)。Properties類可以把Map對象和屬性文件關(guān)聯(lián)起來，從而把Map對象中的key-value對寫入屬性文件，也可以把屬性文件中的屬性名=屬性值加載到Map對象中。由于屬性文件里的屬性名、屬性值只能是字符串類型，所以Properties里的key、value都是字符串類型，該類提供了如下三個方法來修改Properties里的key、value值。
方法：
String getProperty(String key):獲取Properties中指定屬性名對應(yīng)的屬性值，類似于Map的get(Object key)方法
String getProperty(String key,String defaultValue):該方法與前一個方法基本類似，該方法多一個功能，如果Properties中不存在指定key時，該方法返回默認值
Object setProperty(String key,String value):設(shè)置屬性值，類似Hashtable的put方法 除此之外，它還提供了兩個讀、寫屬性文件的方法
void load(InputStream inStream):從屬性文件(以輸入流表示)中加載屬性名=屬性值，把加載到的屬性名=屬性值對追加到Properties里(由于Properties是Hashtable的子類，它不保證key-value對之間的次序)。
void store(OutputStream out,String comments):將Properties中的key-value對寫入指定屬性文件(以輸出流表示)。
5.5?SortedMap和TreeMap
正如Set接口派生出了SortedSet子接口，SortedSet接口有一個TreeSet實現(xiàn)類，Map接口也派生了一個SortedMap子接口，SortedMap也有一個TreeMap實現(xiàn)類。 與TreeSet類似的是，TreeMap也是基于紅黑樹對TreeMap中所有key進行排序，從而保證TreeMap中的鍵值對處于有序狀態(tài)。類似也有兩種排序方式。
排序方式
自然排序：TreeMap的所有key必須實現(xiàn)Comparable接口，而且所有key應(yīng)該是同一個類對象，否則拋出ClassCastException異常 定制排序：創(chuàng)建TreeMap時，傳入一個Comparator對象，該對象負責(zé)對TreeMap中所有key進行排序，采用定制排序時不要求Map的key實現(xiàn)Comparable接口 類似地，TreeSet中判斷兩個元素相等的標(biāo)準(zhǔn)，TreeMap中判斷兩個key相等的標(biāo)準(zhǔn)也是兩個key通過equals比較返回true，而通過compareTo方法返回0，TreeMap即認為這兩個key是相等的。 如果想使用自定義的類作為TreeMap的key，且想讓TreeMap工作良好，重寫該類的equals方法和compareTo方法時應(yīng)該有一致的返回結(jié)果：即兩個key通過equals方法比較返回true時，通過compareTo方法返回0，否則處理會有性能問題，具體可以參考TreeSet。
TreeMap方法???
與TreeSet類似的是，TreeMap提供了系列根據(jù)key順序訪問Map中key-value對方法。
Map.Entry firstEntry():返回該Map中最小key所對應(yīng)的鍵值對，如果該Map為空，則返回null
Object firstKey():返回該Map中的最小key值，如果Map為空，則返回null
Map.Entry lastEntry()：返回該Map中最大key所對應(yīng)的key-value對，如果該Map為空，或不存在這樣的key-value則返回null
Object lastKey()：返回該Map中的最大key值，如果Map為空，或不存在這樣的key都返回null
Map.Entry higherEntry(Object key):返回該Map中key的上確界對應(yīng)的鍵值對
Object higherKey(Object key)：返回key的上確界
Map.Entry lowerEntry(Object key):返回該Map中key的下確界對應(yīng)的鍵值對
Object lowerKey(Object key)：返回key的下確界
NavigableMap subMap(Object fromKey,boolean fromInclusive,Object toKey,boolean toInclusive):返回該Map的子Map，其key的范圍從fromKey(是否包括取決于第二個參數(shù)) 到toKey(是否包括取決于第四個參數(shù))
NavigableMap tailMap(Object fromKey,boolean inclusive):返回該Map的子Map，其key的范圍從fromKey(是否包括取決于第二個參數(shù))
NavigableMap headMap(Object toKey,boolean inclusive):返回該Map的子Map，其key的范圍小于toKey(是否包括取決于第二個參數(shù))
SortedMap subMap(Object fromKey,Object toKey)：返回該Map的子Map，其key的范圍從fromKey(包括)到toKey(不包括)
SortedMap tailMap(Object fromKey):返回該Map的子Map，其key的范圍從fromKey(不包括)
SortedMap headMap(Object toKey):返回該Map的子Map，其key的范圍小于toKey(不包括)
上面的看起來方法挺多：也就是第一個、前一個、后一個、最后一個鍵值對方法，并提供了截取子TreeMap的方法
5.6?WeakHashMap實現(xiàn)類
WeakHashMap與HashMap用法基本類似，但與HashMap區(qū)別在于，HashMap的key保留對實際對象的強引用，這意味著只要該HashMap對象不被銷毀，該HashMap對象所有key所引用的對象不會被垃圾回收，HashMap也不會自動刪除這些key所對應(yīng)的key-value對象；但WeakHashMap的key只保留對實際對象的弱引用，這意味著如果該HashMap對象所有key所引用的對象沒有被其他強引用變量所引用，key所引用的對象可能被垃圾回收，HashMap有可能自動刪除這些key所對應(yīng)的key-value對象 WeakHashMap中的每個key對象保存了實際對象的弱引用，因此，當(dāng)垃圾回收了該key所對應(yīng)的實際對象之后，WeakHashMap會自動刪除key-value對。
1 package chapter7; 2 3 import java.util.*; 4 5 public class TestWeakHashMap { 6 public static void main(String[] args){ 7 //添加一個集合，并添加匿名對象(無變量引用) 8 WeakHashMap whm = new WeakHashMap(); 9 whm.put(new String("English"), "80"); 10 whm.put(new String("Chemistry"), "80"); 11 whm.put(new String("Java"), "80"); 12 System.out.println(whm); 13 //添加一個有變量引用的對象 14 whm.put("Deutsch", "99"); 15 System.out.println("垃圾回收前：" + whm); 16 //通知系統(tǒng)進行垃圾回收 17 System.gc(); 18 //輸出垃圾回收后的結(jié)果 19 System.out.println("垃圾回收后:" + whm); 20 //對比HashMap垃圾處理機制 21 HashMap hm = new HashMap(); 22 hm.put(new String("English"), "80"); 23 hm.put(new String("Chemistry"), "80"); 24 hm.put(new String("Java"), "80"); 25 System.out.println(hm); 26 //添加一個有變量引用的對象 27 hm.put("Deutsch", "99"); 28 System.out.println("垃圾回收前：" + hm); 29 //通知系統(tǒng)進行垃圾回收 30 System.gc(); 31 //輸出垃圾回收后的結(jié)果 32 System.out.println("垃圾回收后:" + hm); 33 34 } 35 } 36 執(zhí)行結(jié)果如下： 37 {Java=80, English=80, Chemistry=80} 38 垃圾回收前：{Java=80, English=80, Deutsch=99, Chemistry=80} 39 垃圾回收后:{Deutsch=99} 40 {Chemistry=80, Java=80, English=80} 41 垃圾回收前：{Chemistry=80, Deutsch=99, Java=80, English=80} 42 垃圾回收后:{Chemistry=80, Deutsch=99, Java=80, English=80}5.7 IdentityHashMap實現(xiàn)類
這個Map實現(xiàn)類的實現(xiàn)機制與HashMap基本相似，但它在處理兩個key相等時比較獨特：在IdentityHashMap中，當(dāng)且僅當(dāng)兩個key嚴(yán)格相等(key1==key2)時，IdentityHashMap才認為兩個key相等，對于普通HashMap而言，只要key1和key2通過equals方法比較返回true，且hashCode值相同即可。 IdentityHashMap是一個特殊的Map實現(xiàn)，它有意違反Map的通常規(guī)范：在IdentityHashMap中，當(dāng)且僅當(dāng)兩個key嚴(yán)格相等(key1==key2)時，IdentityHashMap才認為兩個key相等 IndetityHashMap提供了與HashMap基本類似的方法，null作為key和value，不保證鍵值對之間的順序。
1 package chapter7; 2 3 import java.util.*; 4 /** 5 * Description: 6 * <br/>Copyright (C), 2005-2008, Yeeku.H.Lee 7 * <br/>This program is protected by copyright laws. 8 * <br/>Program Name: 9 * <br/>Date: 10 * @author Yeeku.H.Lee kongyeeku@163.com 11 * @version 1.0 12 */ 13 public class TestIdentityHashMap{ 14 public static void main(String[] args){ 15 IdentityHashMap ihm = new IdentityHashMap(); 16 //下面兩行代碼將會向IdentityHashMap對象中添加2個key-value對 17 ihm.put(new String("語文") , 89); 18 ihm.put(new String("語文") , 78); 19 ihm.put("java" , 93); 20 ihm.put("java" , 98); 21 System.out.println(ihm); 22 } 23 }注意：最后添加的兩個key為java的鍵值對是一樣的，因為java采用的緩存機制，對于同一個字符串，不新建新的對象來浪費內(nèi)存
5.8?EnumMap集合類
EnumMap是一個與枚舉類一起使用的Map實現(xiàn)，EnumMap中所有key都必須是單個枚舉類的枚舉值。創(chuàng)建EnumMap時必須顯式或隱式指定它對應(yīng)的枚舉類。EnumMap在內(nèi)部以數(shù)組形式保存，所以這種實現(xiàn)形式非常緊湊、高效。
EnumMap根據(jù)key的定義時順序來維護鍵值對的次序，當(dāng)使用keySet()、entrySet()、values()等方法來遍歷EnumMap時即可看到這種順序與插入時候順序是一致的。
EnumMap不允許使用null昨晚key值，但允許使用null作為value，如果試圖使用null作為key將拋出NullPointerException異常，如果只是查詢是否包含值為null的key，或者刪除使用刪除值為null的key都不會拋出異常。
與創(chuàng)建普通Map有區(qū)別的是，創(chuàng)建EnumMap時必須指定一個枚舉類，從將該EnumMap和指定枚舉類關(guān)聯(lián)起來。
對于Map的常用實現(xiàn)類而言，HashMap和Hashtable的效率大致相同，因為實現(xiàn)機制幾乎完全一樣，但通常HashMap通常比Hashtable快一點，因為Hashtable額外實現(xiàn)同步操作。 TreeMap通常比HashMap、Hashtable要慢(尤其是插入、刪除鍵值對時候更慢)，因為TreeMap需要額外的紅黑樹操作來維護key之間的次序，但是用TreeMap有一個好處：TreeMap中的鍵值對總是有序的，無序?qū)ｉT進行排序操作。當(dāng)TreeMap被填充后，可以調(diào)用keySet()，取得key組成的Set，然后是用toArray()生成key的數(shù)組，接下來是用Arrays的binarySearch()方法在已排序的數(shù)組中快速地查詢對象。當(dāng)然，通常只有在某些情況下無法使用HashMap的時候才這么做，因為HashMap正是為快速查詢而設(shè)計的，通常使用Map時候首選HashMap，除非需要一個總是排好序的Map時才使用TreeMap。 ? LinkedHashMap比HashMap慢一點，因為它需要維護鏈表來保持Map中key的順序。IndentityHashMap性能沒有特別出色之處，EnumMap性能最好，但它只能使用同一個枚舉類的枚舉值作為key。
5.9 HashSet和HashMap的性能選擇
對于HashSet及其子類而言，它們采用hash算法來決定集合中元素的存儲位置，并通過hash算法來增加集合容積的大小；對于HashMap、Hashtable及其子類而言，它們采用hash算法來決定Map中key的存儲，并通過hash算法來增加key Set容積的大小Hash表里可以存儲元素的位置被稱為"桶(bucket)",通常情況下，單個"桶"里存儲一個元素，此時有最好的性能:hash算法可以根據(jù)hashCode值計算出"桶"的存儲位置，接著從"桶"中取出元素，但hash表的狀態(tài)為open：當(dāng)發(fā)送hash沖突時候，單個桶會存儲多個元素，這些元素以鏈表形式存儲，必須按順序搜索。如下圖
因為HashSet、HashMap、Hashtable都是用hash算法來決定其元素(對HashMap則是key)的存儲，因此HashSet、HashMap的hash表包含如下屬性：
Hash表屬性??
容量(capacity):hash表中桶的數(shù)量
初始化容量(initial capacity)：創(chuàng)建hash表時桶的數(shù)量。HashMap和HashSet都允許在構(gòu)造器中指定初始化容量
尺寸(size)：當(dāng)前hash表中記錄的數(shù)量
負載因子(load factor)：負載因子等于size/capacity。負載因子為0，表示空的hash表，0.5 表示半滿的hash表，以此類推，輕負載的hash表具有沖突少、適宜插入與查詢的特點(但是使用Iterator迭代元素時候會變慢)
除此之外，hash表里還有一個負載極限，負載極限在[0,1]的數(shù)值，負載極限決定了hash表中的最大填滿程度。當(dāng)hash表中的負載因子到達指定的負載極限時，hash表會自動成倍地增加容量(桶的數(shù)量)，并將原有的對象重新分配，放入新的桶內(nèi)，也被稱為rehashing
HashSet與HashMap、Hashtable的構(gòu)造器允許指定一個負載極限，HashSet與HashMap、Hashtable默認的負載極限為0.75， 表明當(dāng)該hash表被填到3/4 時，hash表會發(fā)生rehashing
默認負載極限值0.75 是時間和空間成本上的一種折中：較高的負載極限可以降低hash表所占用的內(nèi)存空間，但會增加查詢數(shù)據(jù)的時間開銷，而查詢是最頻繁的操作；較低的負載極限會增加查詢數(shù)據(jù)性能，但會增加hash表所占用的內(nèi)存空間。通常無須改變HashSet和HashMap的負載極限值。通常不需要將初始化容量設(shè)置太高。
5.10?操作集合工具類Collections
Java提供了一個操作Set、List和Map等集合的工具類：Collections，該工具類提供了大量方法對集合元素進行排序、查詢和修改等操作，還提供了將集合對象設(shè)置為不可變、對集合對象實現(xiàn)同步控制等方法。
5.10.1 排序操作
Collections提供了如下幾個方法對List集合元素進行排序 static void reverse(List list):反轉(zhuǎn)指定List集合中元素的順序 static void shuffle(List list):對List集合元素進行隨機排序(shuffle方法模擬了洗牌動作) static void sort(List list)：根據(jù)元素的自然順序?qū)χ付↙ist集合的元素按升序進行排序 static void sort(List list,Comparator c):根據(jù)指定Comparator產(chǎn)生的順序?qū)ist集合的元素進行排序 static void swap(List list,int i,int j)：將指定List集合中i處元素和j處元素進行交換 static void rotate(List list,int distance)：將指定集合中i處元素和list.length-i-1 處的元素進行交換
5.10.2查找，替換操作??????????????
Collections還提供了如下用于查找、替換集合元素的常用方法 static int binarySearch(List list,Object key):使用二分搜索法搜索指定List集合，以獲得指定對象在List集合中的索引，如果要該方法可以正常工作，必須保證List中的元素已經(jīng)處于有序狀態(tài)
static Object max(Collection coll)：根據(jù)元素的自然順序，返回給定集合中的最大元素 static Object max(Collection coll,Comparator comp)：根據(jù)指定Comparator產(chǎn)生的順序，返回給定集合的最大元素 static Object min(Collection coll)：根據(jù)元素的自然順序，返回給定集合中的最小元素 static Object min(Collection coll,Comparator comp)：根據(jù)指定Comparator產(chǎn)生的順序，返回給定集合的最小元素 static void fill(List list,Object obj)：使用指定元素obj替換指定List集合中的所有元素 static int frequency(Collection c,Object o)：返回指定集合中等于指定對象的元素數(shù)量 static int indexOfSubList(List source,List target)：返回子List對象在母List對象中第一次出現(xiàn)的位置索引；如果母List中沒有這樣的子List，則返回-1
static int lastIndexOfSubList(List source,List target)：返回子List對象在母List對象中最后一次出現(xiàn)的位置索引；如果母List中沒有這樣的子List，則返回-1 static boolean replaceAll(List list,Object oldVal,Object newVal):使用一個新值newVal替換List對象所有的舊值oldVal
5.10.3 同步控制???????????????????????
Collections類中提供了多個synchronizedXxx方法(Xxx代表集合類名稱)，該方法返回指定集合對象對應(yīng)的同步對象，從而可以解決多線程并發(fā)訪問集合時的線程安全問題。 如前所述，Java常用的集合框架中推薦使用的三個實現(xiàn)類：HashSet、ArrayList和HashMap都是線程不安全的，如果有多條線程訪問它們，而且有超過一條線程試圖修改它們，則可能出現(xiàn)錯誤。Collections提供了多個靜態(tài)方法用于創(chuàng)建同步集合。
5.10.4 設(shè)置不可變集合?????????????
Collections提供了如下三類方法來返回一個不可變的集合，Xxx代表集合類名稱 emptyXxx()：返回一個空的、不可變的集合對象，此處的集合可以是List、Set、Map singleonXxx():返回一個只包含指定對象(只有一個或一項元素)的、不可變的集合對象，此處的集合可以是List、Set、Map unmodifiableXxx：返回指定集合對象的不可變視圖。此處的集合可以是List、Set、Map 通過這樣的方法就可以創(chuàng)建"只讀"版本的集合，對象不可修改
5.10.5 煩瑣的：Enumeration
Enumeration接口是Iterator迭代器的古老版本，目前都使用Iterator，保留Enumeration主要是為了照顧那些古老的程序。
6.小結(jié)????????????????????????????????????????????????????????????????????
本部分詳細介紹了Java集合框架的相關(guān)知識。
本部分從Java集合框架體系開始講起，概述了Java集合框架的三個主要體系：Set、List和Map，簡述集合在編程中的重要性。詳細講述了Set、Queue、List、Map接口及各實現(xiàn)類的詳細用法，深入分析了各實現(xiàn)類的機制差異，給出選擇集合實現(xiàn)類的原則，最后給出了Collections工具類的基本用法。
轉(zhuǎn)載于:https://www.cnblogs.com/people/archive/2013/05/08/3067086.html
創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎勵來咯，堅持創(chuàng)作打卡瓜分現(xiàn)金大獎總結(jié)
以上是生活随笔為你收集整理的Java程序设计4——集合类的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 求质数算法的N种境界 (N 10) z
- 下一篇： Javascript之创建对象（原型模式