1、List、Vector、deque與ArrayList、LinkedList
stl提供了三個最基本的容器：vector,list,deque
vector和built-in數組類似，即底層是數組數據結構，線程同步，然而現今被ArrayList代替了，已經很少用了。它擁有一段連續的內存空間，並且起始地址不變，因此它能非常好的支持隨即存取，即[]操作符，但由於它的內存空間是連續的，所以在中間進行插入和刪除會造成內存塊的拷貝，另外，當該數組後的內存空間不夠時，需要重新申請一塊足夠大的內存並進行內存的拷貝。這些都大大影響了vector的效率。對於簡單的小對象，vector的效率優於list。vector在每次擴張容量的時候，將容量擴展2倍，這樣對於小對象來說，效率是很高的。
List在數據結構中表現爲是線性表的方式,List集合中的對象按照一定的順序排放，裏面的內容可以重複，因爲該集合體繫有索引，List<E>集合繼承於Collection<E>，是一個接口，List接口實現的類：ArrayList(實現動態數組)， Vector（實現動態數組） ，LinkedList（實現鏈表）， Stack（實現堆棧）。
deque是一個double-ended queue，它的具體實現不太清楚，但知道它具有以下兩個特點：
它支持[]操作符，也就是支持隨即存取，並且和vector的效率相差無幾。
它支持在兩端的操作：push_back,push_front,pop_back,pop_front等，並且在兩端操作上與list的效率也差不多。
綜上所述：
vector適用：對象數量變化少，簡單對象，隨機訪問元素頻繁
list適用：對象數量變化大，對象複雜，插入和刪除頻繁
最大的區別是,list是雙向的，而vector是單向的。
因此在實際使用時，如何選擇這三個容器中哪一個，應根據你的需要而定，一般應遵循下面的原則：
1、如果你需要高效的隨即存取，而不在乎插入和刪除的效率，使用vector
2、如果你需要大量的插入和刪除，而不關心隨即存取，則應使用list
3、如果你需要隨即存取，而且關心兩端數據的插入和刪除，則應使用deque。
ArrayList 底層採用的是數組形式來保存對象的。特點： 查詢速度很快，但是增刪稍慢，線程不同步。
採用數組這種方式將對象放在連續的位置中，當向集合中添加對象時，數組的大小也隨着改變，這樣它所帶來的有優點是快速的隨機訪問，即使訪問每個元素所帶來的性能問題也是很小的，但缺點就是想其中添加或刪除對象速度慢，當你創建的數組是不確定其容量，所以當我們改變這個數組時就必須在內存中做很多的處理，如你想要數組中任意兩個元素中間添加對象，那麼在內存中數組要移動所有後面的對象。
LinkedList底層使用的是鏈表數據結構。特點： 增刪速度很快，查詢稍慢。
它是通過節點的連接實現鏈表的數據結構，向linkedList中插入或刪除元素的速度是特別快，而隨機訪問的速度相對較慢，這個是由於鏈表本身的性質造成的，在鏈表中，每個節點都包含了前一個節點的引用，後一個節點的引用和節點存儲值，當一個新節點插入式，只需要修改其中相關的前後關係節點引用即可，刪除節點也是一樣。操作對象只需要改變節點的鏈接，新節點可以存放在內存的任何位置，但也就是因爲如此LinkedList雖然存在get()方法，但是這個方法通過遍歷節點來定位所以速度很慢。LinkedList還單獨具addFrist(),addLast(),getFrist(),getLast(),removeFirst(),removeLast()方法，這些方法使得LinkedList可以作爲堆棧，隊列，和雙隊列來使用。
2、 ArrayList對象 list的兩種種遍歷方式：
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
System.out.println("........第一種遍歷方式：foreach遍歷......");
for (Object li : list) {
System.out.println(li);
}
System.out.println("........第二種遍歷方式：ListIterator迭代遍歷......");
ListIterator<String> it = list.listIterator();
while (it.hasNext()) {
Object obj = it.next();
System.out.println(obj);
}
}
}
效果圖：
A
B
C
D
........第二種遍歷方式：ListIterator迭代遍歷......
A
B
C
D
3、使用LinkedList模擬一個堆棧或者隊列數據結構。
即： 堆棧：先進後出 ；隊列： 先進先出。
private LinkedList<Object> link;
linkedListTraversal(){
link = new LinkedList<Object>();
}
public void myAdd(Object obj){
link.addFirst(obj);
}
public Object myGet(){
return link.removeFirst();//先進後出---若要改成先進先出，將removeFirst()改成removeLast（）
}
public boolean isNull(){
return link.isEmpty();
}
public static void main(String[] args) {
linkedListTraversal dl = new linkedListTraversal();
dl.myAdd("hello1");
dl.myAdd("hello2");
dl.myAdd("hello3");
dl.myAdd("hello4");
while(!dl.isNull()){
System.out.println(dl.myGet());
}
}
}
先進後出效果圖：
hello3
hello2
hello1
4、關於ArrayList
（1）特點：ArrayList（動態數組）是Array的複雜版本、動態的增加和減少元素、實現了ICollection和IList接口、靈活的設置數組的大小。
（2）使用場景：ArrayList最常用的用法
一種情況：
ArrayList List = new ArrayList();
for( int i=0;i<10;i++ ){
List.Add(i); } //給數組增加10個Int元素
List.RemoveAt(3);//將第4個元素移除
for( int i=0;i<3;i++ ){
List.Add(i+30);
} //再增加3個元素
Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的數組,拷貝到一個新的數組當中
//類似於Int32[] values = new Int32[List.Count]; List.CopyTo(values);
另一種情況：
ArrayList List = new ArrayList();
List.Add( “string” );
List.Add( 1 );//往數組中添加不同類型的元素
object[] values = List.ToArray(typeof(object)); //正確
string[] values = (string[])List.ToArray(typeof(string)); //錯誤
和數組不一樣，因爲可以轉換爲Object數組，所以往ArrayList裏面添加不同類型的元素是不會出錯的，但是當調用ArrayList方法的時候，要麼傳遞所有元素都可以正確轉型的類型或者Object類型，否則將會拋出無法轉型的異常。
5、ArrayList與Array數組的差別，以及ArrayList的效率問題
（1）ArrayList是Array的複雜版本
ArrayList內部封裝了一個Object類型的數組，從一般的意義來說，它和數組沒有本質的差別，甚至於ArrayList的許多方法，如Index、IndexOf、Contains、Sort等都是在內部數組的基礎上直接調用Array的對應方法。
（2）內部的Object類型的影響
對於一般的引用類型來說，這部分的影響不是很大，但是對於值類型來說，往ArrayList裏面添加和修改元素，都會引起裝箱和拆箱的操作，頻繁的操作可能會影響一部分效率。但是恰恰對於大多數人，多數的應用都是使用值類型的數組。消除這個影響是沒有辦法的，除非你不用它，否則就要承擔一部分的效率損失，不過這部分的損失不會很大。
（3）數組擴容
這是對ArrayList效率影響比較大的一個因素。每當執行Add、AddRange、Insert、InsertRange等添加元素的方法，都會檢查內部數組的容量是否不夠了，如果是，它就會以當前容量的兩倍來重新構建一個數組，將舊元素Copy到新數組中，然後丟棄舊數組，在這個臨界點的擴容操作，應該來說是比較影響效率的。
例1：比如，一個可能有200個元素的數據動態添加到一個以默認16個元素大小創建的ArrayList中，將會經過：16*2*2*2*2 = 256四次的擴容纔會滿足最終的要求，那麼如果一開始就以：ArrayList List = new ArrayList( 210 );的方式創建ArrayList，不僅會減少4次數組創建和Copy的操作，還會減少內存使用。
例2：預計有30個元素而創建了一個ArrayList：ArrayList List = new ArrayList(30);
在執行過程中，加入了31個元素，那麼數組會擴充到60個元素的大小，而這時候不會有新的元素再增加進來，而且有沒有調用TrimSize方法，那麼就有1次擴容的操作，並且浪費了29個元素大小的空間。如果這時候，用：ArrayList List = new ArrayList(40);那麼一切都解決了。所以說，正確的預估可能的元素，並且在適當的時候調用TrimSize方法是提高ArrayList使用效率的重要途徑。
（4）頻繁的調用IndexOf、Contains等方法（Sort、BinarySearch等方法經過優化，不在此列）引起的效率損失
首先，我們要明確一點，ArrayList是動態數組，它不包括通過Key或者Value快速訪問的算法，所以實際上調用IndexOf、Contains等方法是執行的簡單的循環來查找元素，所以頻繁的調用此類方法並不比你自己寫循環並且稍作優化來的快，如果有這方面的要求，建議使用Hashtable或SortedList等鍵值對的集合。
ArrayList al=new ArrayList();
al.Add("How");
al.Add("are");
al.Add("you!");
al.Add(100);
al.Add(200);
al.Add(300);
al.Add(1.2);
al.Add(22.8);
.........
//第一種遍歷 ArrayList 對象的方法
foreach(object o in al)
{
Console.Write(o.ToString()+" ");
}
//第二種遍歷 ArrayList 對象的方法
IEnumerator ie=al.GetEnumerator();
while(ie.MoveNext())
{
Console.Write(ie.Curret.ToString()+" ");
}
//第三種遍歷 ArrayList 對象的方法
利用 ArrayList對象的一個屬性,它返回一此對象中的元素個數.
然後在利用索引
for(int i=0;i<Count;i++)
{
Console.Write(al[i].ToString()+" ");
}