java雙向隊列
『壹』 java簡單問題
下面詳細介紹了 linkedlist 還有其他幾個類似的對象 希望對你有用
祝你好用
ArrayList Vector LinkedList 區別與用法
ArrayList,LinkedList,Vestor這三個類都實現了java.util.List介面，但它們有各自不同的特性，主要如下：
一、同步性
ArrayList,LinkedList是不同步的，而Vestor是的。所以如果要求線程安全的話，可以使用ArrayList或LinkedList，可以節省為同步而耗費開銷。但在多線程的情況下，有時候就不得不使用Vector了。當然，也可以通過一些辦法包裝ArrayList,LinkedList，使他們也達到同步，但效率可能會有所降低。
二、數據增長
從內部實現機制來講ArrayList和Vector都是使用Objec的數組形式來存儲的。當你向這兩種類型中增加元素的時候，如果元素的數目超出了內部數組目前的長度它們都需要擴展內部數組的長度，Vector預設情況下自動增長原來一倍的數組長度，ArrayList是原來的50%,所以最後你獲得的這個集合所佔的空間總是比你實際需要的要大。所以如果你要在集合中保存大量的數據那麼使用Vector有一些優勢，因為你可以通過設置集合的初始化大小來避免不必要的資源開銷。
三、檢索、插入、刪除對象的效率
ArrayList和Vector中，從指定的位置（用index）檢索一個對象，或在集合的末尾插入、刪除一個對象的時間是一樣的，可表示為O(1)。但是，如果在集合的其他位置增加或移除元素那麼花費的時間會呈線形增長：O(n-i)，其中n代表集合中元素的個數，i代表元素增加或移除元素的索引位置。為什麼會這樣呢？以為在進行上述操作的時候集合中第i和第i個元素之後的所有元素都要執行(n-i)個對象的位移操作。
LinkedList中，在插入、刪除集合中任何位置的元素所花費的時間都是一樣的—O(1)，但它在索引一個元素的時候比較慢，為O(i),其中i是索引的位置。
所以，如果只是查找特定位置的元素或只在集合的末端增加、移除元素，那麼使用Vector或ArrayList都可以。如果是對其它指定位置的插入、刪除操作，最好選擇LinkedList
ArrayList 和Vector是採用數組方式存儲數據，此數組元素數大於實際存儲的數據以便增加和插入元素，都允許直接序號索引元素，但是插入數據要設計到數組元素移動等內存操作，所以索引數據快插入數據慢，Vector由於使用了synchronized方法（線程安全）所以性能上比ArrayList要差，LinkedList使用雙向鏈表實現存儲，按序號索引數據需要進行向前或向後遍歷，但是插入數據時只需要記錄本項的前後項即可，所以插入數度較快！
線性表，鏈表，哈希表是常用的數據結構，在進行Java開發時，JDK已經為我們提供了一系列相應的類來實現基本的數據結構。這些類均在java.util包中。本文試圖通過簡單的描述，向讀者闡述各個類的作用以及如何正確使用這些類。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection介面
Collection是最基本的集合介面，一個Collection代表一組Object，即Collection的元素（Elements）。一些Collection允許相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接繼承自Collection的類，Java SDK提供的類都是繼承自Collection的「子介面」如List和Set。
所有實現Collection介面的類都必須提供兩個標準的構造函數：無參數的構造函數用於創建一個空的Collection，有一個Collection參數的構造函數用於創建一個新的Collection，這個新的Collection與傳入的Collection有相同的元素。後一個構造函數允許用戶復制一個Collection。
如何遍歷Collection中的每一個元素？不論Collection的實際類型如何，它都支持一個iterator()的方法，該方法返回一個迭代子，使用該迭代子即可逐一訪問Collection中每一個元素。典型的用法如下：
Iterator it = collection.iterator(); // 獲得一個迭代子
while(it.hasNext()) {
Object obj = it.next(); // 得到下一個元素
}
由Collection介面派生的兩個介面是List和Set。
List介面
List是有序的Collection，使用此介面能夠精確的控制每個元素插入的位置。用戶能夠使用索引（元素在List中的位置，類似於數組下標）來訪問List中的元素，這類似於Java的數組。
和下面要提到的Set不同，List允許有相同的元素。
除了具有Collection介面必備的iterator()方法外，List還提供一個listIterator()方法，返回一個ListIterator介面，和標準的Iterator介面相比，ListIterator多了一些add()之類的方法，允許添加，刪除，設定元素，還能向前或向後遍歷。
實現List介面的常用類有LinkedList，ArrayList，Vector和Stack。
LinkedList類
LinkedList實現了List介面，允許null元素。此外LinkedList提供額外的get，remove，insert方法在LinkedList的首部或尾部。這些操作使LinkedList可被用作堆棧（stack），隊列（queue）或雙向隊列（deque）。
注意LinkedList沒有同步方法。如果多個線程同時訪問一個List，則必須自己實現訪問同步。一種解決方法是在創建List時構造一個同步的List：
List list = Collections.synchronizedList(new LinkedList(...));
ArrayList類
ArrayList實現了可變大小的數組。它允許所有元素，包括null。ArrayList沒有同步。
size，isEmpty，get，set方法運行時間為常數。但是add方法開銷為分攤的常數，添加n個元素需要O(n)的時間。其他的方法運行時間為線性。
每個ArrayList實例都有一個容量（Capacity），即用於存儲元素的數組的大小。這個容量可隨著不斷添加新元素而自動增加，但是增長演算法並沒有定義。當需要插入大量元素時，在插入前可以調用ensureCapacity方法來增加ArrayList的容量以提高插入效率。
和LinkedList一樣，ArrayList也是非同步的（unsynchronized）。
Vector類
Vector非常類似ArrayList，但是Vector是同步的。由Vector創建的Iterator，雖然和ArrayList創建的Iterator是同一介面，但是，因為Vector是同步的，當一個Iterator被創建而且正在被使用，另一個線程改變了Vector的狀態（例如，添加或刪除了一些元素），這時調用Iterator的方法時將拋出，因此必須捕獲該異常。
Stack 類
Stack繼承自Vector，實現一個後進先出的堆棧。Stack提供5個額外的方法使得Vector得以被當作堆棧使用。基本的push和pop方法，還有peek方法得到棧頂的元素，empty方法測試堆棧是否為空，search方法檢測一個元素在堆棧中的位置。Stack剛創建後是空棧。
Set介面
Set是一種不包含重復的元素的Collection，即任意的兩個元素e1和e2都有e1.equals(e2)=false，Set最多有一個null元素。
很明顯，Set的構造函數有一個約束條件，傳入的Collection參數不能包含重復的元素。
請注意：必須小心操作可變對象（Mutable Object）。如果一個Set中的可變元素改變了自身狀態導致Object.equals(Object)=true將導致一些問題。
Map介面
請注意，Map沒有繼承Collection介面，Map提供key到value的映射。一個Map中不能包含相同的key，每個key只能映射一個value。Map介面提供3種集合的視圖，Map的內容可以被當作一組key集合，一組value集合，或者一組key-value映射。
Hashtable類
Hashtable繼承Map介面，實現一個key-value映射的哈希表。任何非空（non-null）的對象都可作為key或者value。
添加數據使用put(key, value)，取出數據使用get(key)，這兩個基本操作的時間開銷為常數。
Hashtable通過initial capacity和load factor兩個參數調整性能。通常預設的load factor 0.75較好地實現了時間和空間的均衡。增大load factor可以節省空間但相應的查找時間將增大，這會影響像get和put這樣的操作。
使用Hashtable的簡單示例如下，將1，2，3放到Hashtable中，他們的key分別是」one」，」two」，」three」：
Hashtable numbers = new Hashtable();
numbers.put(「one」, new Integer(1));
numbers.put(「two」, new Integer(2));
numbers.put(「three」, new Integer(3));
要取出一個數，比如2，用相應的key：
Integer n = (Integer)numbers.get(「two」);
System.out.println(「two = 」 + n);
由於作為key的對象將通過計算其散列函數來確定與之對應的value的位置，因此任何作為key的對象都必須實現hashCode和equals方法。hashCode和equals方法繼承自根類Object，如果你用自定義的類當作key的話，要相當小心，按照散列函數的定義，如果兩個對象相同，即obj1.equals(obj2)=true，則它們的hashCode必須相同，但如果兩個對象不同，則它們的hashCode不一定不同，如果兩個不同對象的hashCode相同，這種現象稱為沖突，沖突會導致操作哈希表的時間開銷增大，所以盡量定義好的hashCode()方法，能加快哈希表的操作。
如果相同的對象有不同的hashCode，對哈希表的操作會出現意想不到的結果（期待的get方法返回null），要避免這種問題，只需要牢記一條：要同時復寫equals方法和hashCode方法，而不要只寫其中一個。
Hashtable是同步的。
HashMap類
HashMap和Hashtable類似，不同之處在於HashMap是非同步的，並且允許null，即null value和null key。，但是將HashMap視為Collection時（values()方法可返回Collection），其迭代子操作時間開銷和HashMap的容量成比例。因此，如果迭代操作的性能相當重要的話，不要將HashMap的初始化容量設得過高，或者load factor過低。
WeakHashMap類
WeakHashMap是一種改進的HashMap，它對key實行「弱引用」，如果一個key不再被外部所引用，那麼該key可以被GC回收。
總結
如果涉及到堆棧，隊列等操作，應該考慮用List，對於需要快速插入，刪除元素，應該使用LinkedList，如果需要快速隨機訪問元素，應該使用ArrayList。
如果程序在單線程環境中，或者訪問僅僅在一個線程中進行，考慮非同步的類，其效率較高，如果多個線程可能同時操作一個類，應該使用同步的類。
要特別注意對哈希表的操作，作為key的對象要正確復寫equals和hashCode方法。
盡量返回介面而非實際的類型，如返回List而非ArrayList，這樣如果以後需要將ArrayList換成LinkedList時，客戶端代碼不用改變。這就是針對抽象編程。
同步性
Vector是同步的。這個類中的一些方法保證了Vector中的對象是線程安全的。而ArrayList則是非同步的，因此ArrayList中的對象並不是線程安全的。因為同步的要求會影響執行的效率，所以如果你不需要線程安全的集合那麼使用ArrayList是一個很好的選擇，這樣可以避免由於同步帶來的不必要的性能開銷。
數據增長
從內部實現機制來講ArrayList和Vector都是使用數組(Array)來控制集合中的對象。當你向這兩種類型中增加元素的時候，如果元素的數目超出了內部數組目前的長度它們都需要擴展內部數組的長度，Vector預設情況下自動增長原來一倍的數組長度，ArrayList是原來的50%,所以最後你獲得的這個集合所佔的空間總是比你實際需要的要大。所以如果你要在集合中保存大量的數據那麼使用Vector有一些優勢，因為你可以通過設置集合的初始化大小來避免不必要的資源開銷。
使用模式
在ArrayList和Vector中，從一個指定的位置（通過索引）查找數據或是在集合的末尾增加、移除一個元素所花費的時間是一樣的，這個時間我們用O(1)表示。但是，如果在集合的其他位置增加或移除元素那麼花費的時間會呈線形增長：O(n-i)，其中n代表集合中元素的個數，i代表元素增加或移除元素的索引位置。為什麼會這樣呢？以為在進行上述操作的時候集合中第i和第i個元素之後的所有元素都要執行位移的操作。這一切意味著什麼呢？
這意味著，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那麼使用Vector或ArrayList都可以。如果是其他操作，你最好選擇其他的集合操作類。比如，LinkList集合類在增加或移除集合中任何位置的元素所花費的時間都是一樣的?O(1)，但它在索引一個元素的使用缺比較慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因為你可以簡單的使用索引來代替創建iterator對象的操作。LinkList也會為每個插入的元素創建對象，所有你要明白它也會帶來額外的開銷。
最後，在《Practical Java》一書中Peter Haggar建議使用一個簡單的數組（Array）來代替Vector或ArrayList。尤其是對於執行效率要求高的程序更應如此。因為使用數組(Array)避免了同步、額外的方法調用和不必要的重新分配空間的操作。
『貳』 java arraylist是有序的嗎
是有序的。
比如：List<Integer> list=new ArrayList<Integer>();
list.get(0)
一個list，第一個放進去是1，第二個放進去是2：
List<Integer> numList=new ArrayList<>();
numList.add(1);
numList.add(2);
當取第一個時numList.get(0)；(下標從0開始)
列印它出來還是：1
(2)java雙向隊列擴展閱讀：
LinkedList ：對順序訪問進行了優化，向List中間插入與刪除的開銷並不大。隨機訪問則相對較慢。(使用ArrayList代替)還具有下列方 法：addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast()， 這些方法 (沒有在任何介面或基類中定義過)使得LinkedList可以當作堆棧、隊列和雙向隊列使用。
『叄』 Java中Vector和ArrayList的區別
首先看這兩類都實現List介面，而List介面一共有三個實現類，分別是ArrayList、Vector和LinkedList。List用於存放多個元素，能夠維護元素的次序，並且允許元素的重復。3個具體實現類的相關區別如下：
ArrayList是最常用的List實現類，內部是通過數組實現的，它允許對元素進行快速隨機訪問。數組的缺點是每個元素之間不能有間隔，當數組大小不滿足時需要增加存儲能力，就要講已經有數組的數據復制到新的存儲空間中。當從ArrayList的中間位置插入或者刪除元素時，需要對數組進行復制、移動、代價比較高。因此，它適合隨機查找和遍歷，不適合插入和刪除。
Vector與ArrayList一樣，也是通過數組實現的，不同的是它支持線程的同步，即某一時刻只有一個線程能夠寫Vector，避免多線程同時寫而引起的不一致性，但實現同步需要很高的花費，因此，訪問它比訪問ArrayList慢。
LinkedList是用鏈表結構存儲數據的，很適合數據的動態插入和刪除，隨機訪問和遍歷速度比較慢。另外，他還提供了List介面中沒有定義的方法，專門用於操作表頭和表尾元素，可以當作堆棧、隊列和雙向隊列使用。
查看Java源代碼，發現當數組的大小不夠的時候，需要重新建立數組，然後將元素拷貝到新的數組內，ArrayList和Vector的擴展數組的大小不同。
ArrayList中：
1publicbooleanadd(Ee){
2
3ensureCapacity(size+1);//增加元素，判斷是否能夠容納。不能的話就要新建數組
4
5elementData[size++]=e;
6
7returntrue;
8
9}
10
11publicvoidensureCapacity(intminCapacity){
12
13modCount++;
14
15intoldCapacity=elementData.length;
16
17if(minCapacity>oldCapacity){
18
19ObjectoldData[]=elementData;//此行沒看出來用處，不知道開發者出於什麼考慮
20
21intnewCapacity=(oldCapacity*3)/2+1;//增加新的數組的大小
22
23if(newCapacity<minCapacity)
24
25newCapacity=minCapacity;
26
27//,sothisisawin:
28
29elementData=Arrays.Of(elementData,newCapacity);
30
31}
32
33}
34
35
Vector中：
(intminCapacity){
2
3intoldCapacity=elementData.length;
4
5if(minCapacity>oldCapacity){
6
7Object[]oldData=elementData;
8
9intnewCapacity=(capacityIncrement>0)?
10
11(oldCapacity+capacityIncrement):(oldCapacity*2);
12
13if(newCapacity<minCapacity){
14
15newCapacity=minCapacity;
16
17}
18
19elementData=Arrays.Of(elementData,newCapacity);
20
21}
22
23}
24
25
關於ArrayList和Vector區別如下：
ArrayList在內存不夠時默認是擴展50%+1個，Vector是默認擴展1倍。
Vector提供indexOf(obj,start)介面，ArrayList沒有。
Vector屬於線程安全級別的，但是大多數情況下不使用Vector，因為線程安全需要更大的系統開銷。
『肆』 在Java中ArrayList、LinkedList、HashMap的區別是什麼
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
LinkedList類
LinkedList實現了List介面，允許null元素。此外LinkedList提供額外的get，remove，insert方法在LinkedList的首部或尾部。這些操作使LinkedList可被用作堆棧（stack），隊列（queue）或雙向隊列（deque）。
注意LinkedList沒有同步方法。如果多個線程同時訪問一個List，則必須自己實現訪問同步。一種解決方法是在創建List時構造一個同步的List：
List
list
=
Collections.synchronizedList(new
LinkedList(...));
ArrayList類
ArrayList實現了可變大小的數組。它允許所有元素，包括null。ArrayList沒有同步。
size，isEmpty，get，set方法運行時間為常數。但是add方法開銷為分攤的常數，添加n個元素需要O(n)的時間。其他的方法運行時間為線性。
每個ArrayList實例都有一個容量（Capacity），即用於存儲元素的數組的大小。這個容量可隨著不斷添加新元素而自動增加，但是增長演算法並沒有定義。當需要插入大量元素時，在插入前可以調用ensureCapacity方法來增加ArrayList的容量以提高插入效率。
和LinkedList一樣，ArrayList也是非同步的（unsynchronized）。
HashMap類
HashMap繼承Map介面，實現一個key-value映射的哈希表。任何非空（non-null）的對象都可作為key或者value。
總結
如果涉及到堆棧，隊列等操作，應該考慮用List，對於需要快速插入，刪除元素，應該使用LinkedList，如果需要快速隨機訪問元素，應該使用ArrayList。
『伍』 java中collection是什麼怎麼理解怎麼使用
collection是個介面（常用作集合用），它下面有兩個子介面分別為
（1）List（2）set
其中List是有序可重復集，set是無序不可重復集。
List又分為三類（1）ArrayList（2）LinkList（3）Vector
ArrayList內部由數組實現，適合查詢；
LinkList內部由鏈表實現，適合增刪改。
Vector幾乎用不到
set又分為（1）HashSet（2）treeSet
treeSet是二叉樹，有序的
HashSet採用散列存儲，是無序的。
另外collection是集合的介面
collections是集合的工具類
『陸』 java對象從queue隊列中出隊，對象的一個參數變為null
你說的是雙向隊列Deque<E>吧，隊列根本沒有offerLast方法。
你這上下文代碼也沒有，我只能猜測著試了一下：
確實是para1、para2先後出隊，而且也沒啥null的情況發生啊。
你檢查是不是入隊之前那個List就有問題，它本來就是null？可以在調試模式下跟蹤一下隊列的情況。
另外糾正一下，啥叫對象的參數啊，我一下都沒明白過來，請叫人家成員變數。
『柒』 「每天一道面試題」Java中的阻塞隊列有哪些
Java里的阻塞隊列有以下幾種：
ArrayBlockingQueue ：一個由數組結構組成的有界阻塞隊列。
LinkedBlockingQueue ：一個由鏈表結構組成的有界阻塞隊列。
PriorityBlockingQueue ：一個支持優先順序排序的無界阻塞隊列。
DelayQueue：一個使用優先順序隊列實現的無界阻塞隊列。
SynchronousQueue：一個不存儲元素的阻塞隊列。
LinkedTransferQueue：一個由鏈表結構組成的無界阻塞隊列。
LinkedBlockingDeque：一個由鏈表結構組成的雙向阻塞隊列。
『捌』 JAVA集合框架的後續版本
自Java1.2之後Java版本統稱為Java2，Java2中的容器類庫才可以說是一種真正意義上的集合框架的實現。基本完全重新設計，但是又對Java1中的一些容器類庫在新的設計上進行了保留，這主要是為了向下兼容的目的，當用Java2開發程序時，應盡量避免使用它們，Java2的集合框架已經完全可以滿足你的需求。有一點需要提醒的是，在Java1中容器類庫是同步化的，而Java2中的容器類庫都是非同步化，這可能是對執行效率進行考慮的結果。
Java2中的集合框架提供了一套設計優良的介面和類，使程序員操作成批的數據或對象元素極為方便。這些介面和類有很多對抽象數據類型操作的API，而這是我們常用的且在數據結構中熟知的。例如Maps，Sets，Lists，Arrays等。並且Java用面向對象的設計對這些數據結構和演算法進行了封裝，這就極大的減化了程序員編程時的負擔。程序員也可以以這個集合框架為基礎，定義更高級別的數據抽象，比如棧、隊列和線程安全的集合等，從而滿足自己的需要。
Java2的集合框架，抽其核心，主要有三類：List、Set和Map。List和Set繼承了Collection，而Map則獨成一體。初看上去可能會對Map獨成一體感到不解，它為什麼不也繼承Collection呢？但是仔細想想，這種設計是合理的。一個Map提供了通過Key對Map中存儲的Value進行訪問，也就是說它操作的都是成對的對象元素，比如put()和get()方法，而這是一個Set或List所不就具備的。當然在需要時，你可以由keySet()方法或values()方法從一個Map中得到鍵的Set集或值的Collection集。 Collection介面提供了一組操作成批對象的方法
它提供了基本操作如添加、刪除。它也支持查詢操作如是否為空isEmpty()方法等。為了支持對Collection進行獨立操作，Java的集合框架給出了一個Iterator，它使得你可以泛型操作一個Collection，而不需知道這個Collection的具體實現類型是什麼。它的功能與Java1中的Enumeration類似，只是更易掌握和使用，功能也更強大。在建立集合框架時，Sun的開發團隊考慮到需要提供一些靈活的介面，用來操作成批的元素，又為了設計的簡便，就把那些對集合進行可選操作的方法與基本方法放到了一起。因為一個介面的實現者必須提供對介面中定義的所有方法的實現，這就需要一種途徑讓調用者知道它正在調用的可選方法當前不支持。最後開發團隊選擇使用一種信號，也即拋出一種不支持操作例外(UnsupportedOperationException)，如果你在使用一個Collection中遇到一個上述的例外，那就意味著你的操作失敗，比如你對一個只讀Collection添加一個元素時，你就會得到一個不支持操作例外。在你實現一個集合介面時，你可以很容易的在你不想讓用戶使用的方法中拋出UnsupportOperationException來告訴使用者這個方法當前沒有實現，UnsupportOperationException是RuntimeException的一個擴展。
另外Java2的容器類庫還有一種Fail fast的機制。比如你正在用一個Iterator遍歷一個容器中的對象，這時另外一個線程或進程對那個容器進行了修改，那麼再用next()方法時可能會有災難性的後果，而這是你不願看到的，這時就會引發一個例外。這就是fail－fast。Collection的功能
下面這張表給出了Collection的所有功能，也就是你能用Set和List做什麼事（不包括從Object自動繼承過來的方法）。（List還有一些額外的功能。）Map不是繼承Collection的，所以我們會區別對待。
boolean add(Object)：確保容器能持有你傳給它的那個參數。如果沒有把它加進去，就返回false。（這是個「可選」的方法，本章稍後會再作解釋。）
boolean addAll(Collection)：加入參數Collection所含的所有元素。只要加了元素，就返回true。
void clear()：清除容器所保存的所有元素。（「可選」）
boolean contains(Object)：如果容器持有參數Object，就返回true。
boolean containsAll(Collection)：如果容器持有參數Collection所含的全部元素，就返回true。 boolean isEmpty()：如果容器裡面沒有保存任何元素，就返回true。
Iterator iterator()：返回一個可以在容器的各元素之間移動的Iterator。
boolean removeAll(Collection)：刪除容器裡面所有參數Collection所包含的元素。只要刪過東西，就返回true。（「可選」）
boolean retainAll(Collection)：只保存參數Collection所包括的元素（集合論中「交集」的概念）。如果發生過變化，則返回true。（「可選」）
int size()：返回容器所含元素的數量。
Object[] toArray()：返回一個包含容器中所有元素的數組。
Object[] toArray(Object[] a)：返回一個包含容器中所有元素的數組，且這個數組不是普通的Object數組，它的類型應該同參數數組a的類型相同（要做類型轉換）。
注意，這里沒有能進行隨機訪問的get()方法。這是因為Collection還包括Set。而Set有它自己的內部順序（因此隨機訪問是毫無意義的）。所以如果你要檢查Collection的元素，你就必須使用迭代器。
接下來講List, Set和Map的各種實現了，每講一種容器，我都會（用星號）告訴你默認情況下應該選用哪種實現。 List介面對Collection進行了簡單的擴充
它的具體實現類常用的有ArrayList和LinkedList。你可以將任何東西放到一個List容器中，並在需要時從中取出。ArrayList從其命名中可以看出它是一種類似數組的形式進行存儲，因此它的隨機訪問速度極快，而LinkedList的內部實現是鏈表，它適合於在鏈表中間需要頻繁進行插入和刪除操作。在具體應用時可以根據需要自由選擇。前面說的Iterator只能對容器進行向前遍歷，而ListIterator則繼承了Iterator的思想，並提供了對List進行雙向遍歷的方法。List的功能
List的基本用法是相當簡單的。雖然絕大多數時候，你只是用add()加對象，用get()取對象，用iterator()獲取這個序列的Iterator，但List還有一些別的很有用的方法。
實際上有兩種List：擅長對元素進行隨機訪問的，較常用的ArrayList，和更強大的LinkedList。LinkedList不是為快速的隨機訪問而設計的，但是它卻有一組更加通用的方法。
List（介面）：List的最重要的特徵就是有序；它會確保以一定的順序保存元素。List在Collection的基礎上添加了大量方法，使之能在序列中間插入和刪除元素。（只對LinkedList推薦使用。）List可以製造ListIterator對象，你除了能用它在List的中間插入和刪除元素之外，還能用它沿兩個方向遍歷List。
ArrayList*：一個用數組實現的List。能進行快速的隨機訪問，但是往列表中間插入和刪除元素的時候比較慢。ListIterator只能用在反向遍歷ArrayList的場合，不要用它來插入和刪除元素，因為相比LinkedList，在ArrayList裡面用ListIterator的系統開銷比較高。
LinkedList：對順序訪問進行了優化。在List中間插入和刪除元素的代價也不高。隨機訪問的速度相對較慢。（用ArrayList吧。）此外它還有addFirst()，addLast()，getFirst()，getLast()，removeFirst()和removeLast()等方法（這些方法，介面和基類均未定義），你能把它當成棧（stack），隊列（queue）或雙向隊列（deque）來用。
記住，容器只是一個存儲對象的盒子。如果這個小盒子能幫你解決所有的問題，那你就用不著去管它是怎麼實現的（在絕大多數情況下，這是使用對象的基本概念）。如果開發環境裡面還有一些別的，會造成固定的性能開銷的因素存在，那麼ArrayList和LinkedList之間的性能差別就會變得不那麼重要了。你只需要它們中的一個，你甚至可以想像有這樣一種「完美」的抽象容器；它能根據用途，自動地切換其底層的實現。
LinkedList的用途
用LinkedList做一個棧
「棧（stack）」有時也被稱為「後進先出」（LIFO）的容器。就是說，最後一個被「壓」進棧中的東西，會第一個「彈」出來。同其他Java容器一樣，壓進去和彈出來的東西都是Object，所以除非你只用Object的功能，否則就必須對彈起來的東西進行類型轉換。
LinkedList的方法能直接實現棧的功能，所以你完全可以不寫Stack而直接使用LinkedList。
如果你只想要棧的功能，那麼繼承就不太合適了，因為繼承出來的是一個擁有LinkedList的所有方法的類。
用LinkedList做一個隊列
隊列（queue）是一個「先進先出」（FIFO）容器。也就是，你把一端把東西放進去，從另一端把東西取出來。所以你放東西的順序也就是取東西的順序。LinkedList有支持隊列的功能的方法，所以它也能被當作Queue來用。
還能很輕易地用LinkedList做一個deque（雙向隊列）。它很像隊列，只是你可以從任意一端添加和刪除元素。 Set介面也是Collection的一種擴展
與List不同的是，在Set中的對象元素不能重復，也就是說你不能把同樣的東西兩次放入同一個Set容器中。它的常用具體實現有HashSet和TreeSet類。HashSet能快速定位一個元素，但是你放到HashSet中的對象需要實現hashCode()方法，它使用了前面說過的哈希碼的演算法。而TreeSet則將放入其中的元素按序存放，這就要求你放入其中的對象是可排序的，這就用到了集合框架提供的另外兩個實用類Comparable和Comparator。一個類是可排序的，它就應該實現Comparable介面。有時多個類具有相同的排序演算法，那就不需要在每分別重復定義相同的排序演算法，只要實現Comparator介面即可。集合框架中還有兩個很實用的公用類：Collections和Arrays。Collections提供了對一個Collection容器進行諸如排序、復制、查找和填充等一些非常有用的方法，Arrays則是對一個數組進行類似的操作。Set的功能
Set的介面就是Collection的，所以不像那兩個List，它沒有額外的功能。實際上Set確確實實就是一個Collection－－只不過行為方式不同罷了。（這是繼承和多態性的完美運用：表達不同地行為。）Set會拒絕持有多個具有相同值的對象的實例（對象的「值」又是由什麼決定的呢？這個問題比較復雜，我們以後會講）。
Set（介面）：加入Set的每個元素必須是唯一的；否則，Set是不會把它加進去的。要想加進Set，Object必須定義equals()，這樣才能標明對象的唯一性。Set的介面和Collection的一摸一樣。Set的介面不保證它會用哪種順序來存儲元素。
HashSet*：為優化查詢速度而設計的Set。要放進HashSet裡面的Object還得定義hashCode()。
TreeSet：是一個有序的Set，其底層是一顆樹。這樣你就能從Set裡面提取一個有序序列了。
LinkedHashSet(JDK 1.4)：一個在內部使用鏈表的Set，既有HashSet的查詢速度，又能保存元素被加進去的順序（插入順序）。用Iterator遍歷Set的時候，它是按插入順序進行訪問的。
HashSet保存對象的順序是和TreeSet和LinkedHashSet不一樣的。這是因為它們是用不同的方法來存儲和查找元素的。（TreeSet用了一種叫紅黑樹的數據結構【red-black tree data structure】來為元素排序，而HashSet則用了「專為快速查找而設計」的散列函數。LinkedHashSet在內部用散列來提高查詢速度，但是它看上去像是用鏈表來保存元素的插入順序的。）你寫自己的類的時候，一定要記住，Set要有一個判斷以什麼順序來存儲元素的標准，也就是說你必須實現Comparable介面，並且定義compareTo()方法。
SortedSet
SortedSet（只有TreeSet這一個實現可用）中的元素一定是有序的。這使得SortedSet介面多了一些方法：
Comparator comparator()：返回Set所使用的Comparator對象，或者用null表示它使用Object自有的排序方法。
Object first()：返回最小的元素。
Object last()：返回最大的元素。
SortedSet subSet(fromElement, toElement)：返回Set的子集，其中的元素從fromElement開始到toElement為止（包括fromElement，不包括toElement）。
SortedSet headSet(toElement)：返回Set的子集，其中的元素都應小於toElement。
SortedSet headSet(toElement)：返回Set的子集，其中的元素都應大於fromElement。
注意，SortedSet意思是「根據對象的比較順序」，而不是「插入順序」進行排序. Map是一種把鍵對象和值對象進行關聯的容器
一個值對象又可以是一個Map，依次類推，這樣就可形成一個多級映射。對於鍵對象來說，像Set一樣，一個Map容器中的鍵對象不允許重復，這是為了保持查找結果的一致性;如果有兩個鍵對象一樣，那你想得到那個鍵對象所對應的值對象時就有問題了，可能你得到的並不是你想的那個值對象，結果會造成混亂，所以鍵的唯一性很重要，也是符合集合的性質的。當然在使用過程中，某個鍵所對應的值對象可能會發生變化，這時會按照最後一次修改的值對象與鍵對應。對於值對象則沒有唯一性的要求。你可以將任意多個鍵都映射到一個值對象上，這不會發生任何問題（不過對你的使用卻可能會造成不便，你不知道你得到的到底是那一個鍵所對應的值對象）。Map有兩種比較常用的實現：HashMap和TreeMap。HashMap也用到了哈希碼的演算法，以便快速查找一個鍵，TreeMap則是對鍵按序存放，因此它便有一些擴展的方法，比如firstKey(),lastKey()等，你還可以從TreeMap中指定一個范圍以取得其子Map。鍵和值的關聯很簡單，用put(Object key,Object value)方法即可將一個鍵與一個值對象相關聯。用get(Object key)可得到與此key對象所對應的值對象。
Map的功能
ArrayList能讓你用數字在一個對象序列裡面進行選擇，所以從某種意義上講，它是將數字和對象關聯起來。但是，如果你想根據其他條件在一個對象序列裡面進行選擇的話，那又該怎麼做呢？棧就是一個例子。它的標準是「選取最後一個被壓入棧的對象」。我們常用的術語map，dictionary，或associative array就是一種非常強大的，能在序列裡面進行挑選的工具。從概念上講，它看上去像是一個ArrayList，但它不用數字，而是用另一個對象來查找對象！這是一種至關重要的編程技巧。
這一概念在Java中表現為Map。put(Object key, Object value)方法會往Map裡面加一個值，並且把這個值同鍵（你查找時所用的對象）聯系起來。給出鍵之後，get(Object key)就會返回與之相關的值。你也可以用containsKey()和containsValue()測試Map是否包含有某個鍵或值。
Java標准類庫里有好幾種Map：HashMap，TreeMap，LinkedHashMap，WeakHashMap，以及IdentityHashMap。它們都實現了Map的基本介面，但是在行為方式方面有著明顯的詫異。這些差異體現在，效率，持有和表示對象pair的順序，持有對象的時間長短，以及如何決定鍵的相等性。
性能是Map所要面對的一個大問題。如果你知道get()時怎麼工作的，你就會發覺（比方說）在ArrayList裡面找對象會是相當慢的。而這正是HashMap的強項。它不是慢慢地一個個地找這個鍵，而是用了一種被稱為hash code的特殊值來進行查找的。散列（hash）時一種演算法，它會從目標對象當中提取一些信息，然後生成一個表示這個對象的「相對獨特」的int。hashCode()是Object根類的方法，因此所有Java對象都能生成hash code。HashMap則利用對象的hashCode()來進行快速的查找。這樣性能就有了急劇的提高。
Map（介面）：維持鍵－－值的關系（既pairs），這樣就能用鍵來找值了。
HashMap*：基於hash表的實現。（用它來代替Hashtable。）提供時間恆定的插入與查詢。在構造函數種可以設置hash表的capacity和load factor。可以通過構造函數來調節其性能。
LinkedHashMap(JDK 1.4)：很像HashMap，但是用Iterator進行遍歷的時候，它會按插入順序或最先使用的順序（least-recently-used(LRU)order）進行訪問。除了用Iterator外，其他情況下，只是比HashMap稍慢一點。用Iterator的情況下，由於是使用鏈表來保存內部順序，因此速度會更快。
TreeMap：基於紅黑樹數據結構的實現。當你查看鍵或pair時，會發現它們時按順序（根據Comparable或Comparator，我們過一會講）排列的。TreeMap的特點時，你所得到的是一個有序的Map。TreeMap是Map中唯一有subMap()方法的實現。這個方法能讓你獲取這個樹中的一部分。
WeakHashMap：一個weak key的Map，是為某些特殊問題而設計的。它能讓Map釋放其所持有的對象。如果某個對象除了在Map當中充當鍵之外，在其他地方都沒有其reference的話，那它將被當作垃圾回收。
IdentityHashMap(JDK 1.4)：一個用==，而不是equals()來比較鍵的hashmap。不是為我們平常使用而設計的，是用來解決特殊問題的。
散列是往Map里存數據的常用演算法。
SortedMap
SortedMap（只有TreeMap這一個實現）的鍵肯定是有序的，因此這個介面裡面就有一些附加功能的方法了。
Comparator comparator()：返回Map所使用的comparator，如果是用Object內置的方法的話，則返回null。
Object firstKey()：返回第一個鍵。
Object lastKey()：返回最後一個鍵。
SortedMap subMap(fromKey, toKey)：返回這個Map的一個子集，其鍵從fromKey開始到toKey為止，包括前者，不包括後者。
SortedMap headMap(toKey)：返回這個Map的一個子集，其鍵均小於toKey。
SortedMap tailMap(fromKey)：返回這個Map的一個子集，其鍵均大於等於fromKey。
pair是按key的順序存儲的，由於TreeMap有順序的概念，因此「位置」是有意義的，所以你可以去獲取它的第一個和最後一個元素，以及它的子集。
LinkedHashMap
為了提高速度，LinkedHashMap對所有東西都做了hash，而且遍歷的時候（println()會遍歷整個Map，所以你能看到這個過程）還會按插入順序返回pair。此外，你還可以在LinkedHashMap的構造函數裡面進行配置，讓它使用基於訪問的LRU（least-recently-used）演算法，這樣還沒被訪問過的元素（同時也是要刪除的候選對象）就會出現在隊列的最前頭。這樣，為節省資源而寫一個定時清理的程序就變得很簡單了。