ArrayList和LinkedList的區別
ArrayList和Vector使用了數組的實現，可以認為ArrayList或者Vector封裝了對內部數組的操作，比如向數組中添加，刪除，插入新的元素或者數據的擴展和重定向。
LinkedList使用了循環雙向鏈表數據結構。與基於數組ArrayList相比，這是兩種截然不同的實現技術，這也決定了它們將適用於完全不同的工作場景。
LinkedList鏈表由一系列表項連接而成。一個表項總是包含3個部分：元素內容，前驅表和後驅表，如圖所示：
在下圖展示了一個包含3個元素的LinkedList的各個表項間的連接關系。在JDK的實現中，無論LikedList是否為空，鏈表內部都有一個header表項，它既表示鏈表的開始，也表示鏈表的結尾。表項header的後驅表項便是鏈表中第一個元素，表項header的前驅表項便是鏈表中最後一個元素。
下面以增加和刪除元素為例比較ArrayList和LinkedList的不同之處：
（1）增加元素到列表尾端：
在ArrayList中增加元素到隊列尾端的代碼如下：
public boolean add(E e){
ensureCapacity(size+1);//確保內部數組有足夠的空間
elementData[size++]=e;//將元素加入到數組的末尾，完成添加
return true;
}
ArrayList中add()方法的性能決定於ensureCapacity()方法。ensureCapacity()的實現如下：
public vod ensureCapacity(int minCapacity){
modCount++;
int oldCapacity=elementData.length;
if(minCapacity>oldCapacity){ //如果數組容量不足，進行擴容
Object[] oldData=elementData;
int newCapacity=(oldCapacity*3)/2+1; //擴容到原始容量的1.5倍
if(newCapacitty<minCapacity) //如果新容量小於最小需要的容量，則使用最小
可以看到，只要ArrayList的當前容量足夠大，add()操作的效率非常高的。只有當ArrayList對容量的需求超出當前數組大小時，才需要進行擴容。擴容的過程中，會進行大量的數組復制操作。而數組復制時，最終將調用System.arraycopy()方法，因此add()操作的效率還是相當高的。
LinkedList 的add()操作實現如下，它也將任意元素增加到隊列的尾端：
public boolean add(E e){
addBefore(e,header);//將元素增加到header的前面
return true;
}
其中addBefore()的方法實現如下：
private Entry<E> addBefore(E e,Entry<E> entry){
Entry<E> newEntry = new Entry<E>(e,entry,entry.previous);
newEntry.provious.next=newEntry;
newEntry.next.previous=newEntry;
size++;
modCount++;
return newEntry;
}
可見，LinkeList由於使用了鏈表的結構，因此不需要維護容量的大小。從這點上說，它比ArrayList有一定的性能優勢，然而，每次的元素增加都需要新建一個Entry對象，並進行更多的賦值操作。在頻繁的系統調用中，對性能會產生一定的影響。
（2）增加元素到列表任意位置
除了提供元素到List的尾端，List接口還提供了在任意位置插入元素的方法：void add(int index,E element);
由於實現的不同，ArrayList和LinkedList在這個方法上存在一定的性能差異，由於ArrayList是基於數組實現的，而數組是一塊連續的內存空間，如果在數組的任意位置插入元素，必然導致在該位置後的所有元素需要重新排列，因此，其效率相對會比較低。
以下代碼是ArrayList中的實現：
public void add(int index,E element){
if(index>size||index<0)
throw new IndexOutOfBoundsException(
"Index:"+index+",size: "+size);
ensureCapacity(size+1);
System.arraycopy(elementData,index,elementData,index+1,size-index);
elementData[index] = element;
size++;
}
可以看到每次插入操作，都會進行一次數組復制。而這個操作在增加元素到List尾端的時候是不存在的，大量的數組重組操作會導致系統性能低下。並且插入元素在List中的位置越是靠前，數組重組的開銷也越大。
而LinkedList此時顯示了優勢：
public void add(int index,E element){
addBefore(element,(index==size?header:entry(index)));
}
可見，對LinkedList來說，在List的尾端插入數據與在任意位置插入數據是一樣的，不會因為插入的位置靠前而導致插入的方法性能降低。
（3）刪除任意位置元素
對於元素的刪除，List接口提供了在任意位置刪除元素的方法：
public E remove(int index);
對ArrayList來說，remove()方法和add()方法是雷同的。在任意位置移除元素後，都要進行數組的重組。ArrayList的實現如下：
public E remove(int index){
RangeCheck(index);
modCount++;
E oldValue=(E) elementData[index];
int numMoved=size-index-1;
if(numMoved>0)
System.arraycopy(elementData,index+1,elementData,index,numMoved);
elementData[--size]=null;
return oldValue;
}
可以看到，在ArrayList的每一次有效的元素刪除操作後，都要進行數組的重組。並且刪除的位置越靠前，數組重組時的開銷越大。
public E remove(int index){
return remove(entry(index));
}
private Entry<E> entry(int index){
if(index<0 || index>=size)
throw new IndexOutBoundsException("Index:"+index+",size:"+size);
Entry<E> e= header;
if(index<(size>>1)){//要刪除的元素位於前半段
for(int i=0;i<=index;i++)
e=e.next;
}else{
for(int i=size;i>index;i--)
e=e.previous;
}
return e;
}
在LinkedList的實現中，首先要通過循環找到要刪除的元素。如果要刪除的位置處於List的前半段，則從前往後找；若其位置處於後半段，則從後往前找。因此無論要刪除較為靠前或者靠後的元素都是非常高效的；但要移除List中間的元素卻幾乎要遍歷完半個List，在List擁有大量元素的情況下，效率很低。
（4）容量參數
容量參數是ArrayList和Vector等基於數組的List的特有性能參數。它表示初始化的數組大小。當ArrayList所存儲的元素數量超過其已有大小時。它便會進行擴容，數組的擴容會導致整個數組進行一次內存復制。因此合理的數組大小有助於減少數組擴容的次數，從而提高系統性能。
public ArrayList(){
this(10);
}
public ArrayList (int initialCapacity){
super();
if(initialCapacity<0)
throw new IllegalArgumentException("Illegal Capacity:"+initialCapacity)
this.elementData=new Object[initialCapacity];
}
ArrayList提供了一個可以制定初始數組大小的構造函數：
public ArrayList(int initialCapacity)
現以構造一個擁有100萬元素的List為例，當使用默認初始化大小時，其消耗的相對時間為125ms左右，當直接制定數組大小為100萬時，構造相同的ArrayList僅相對耗時16ms。
（5）遍歷列表
遍歷列表操作是最常用的列表操作之一，在JDK1.5之後，至少有3中常用的列表遍歷方式：forEach操作，叠代器和for循環。
String tmp;
long start=System.currentTimeMills(); //ForEach
for(String s:list){
tmp=s;
}
System.out.println("foreach spend:"+(System.currentTimeMills()-start));
start = System.currentTimeMills();
for(Iterator<String> it=list.iterator();it.hasNext();){
tmp=it.next();
}
System.out.println("Iterator spend;"+(System.currentTimeMills()-start));
start=System.currentTimeMills();
int size=;list.size();
for(int i=0;i<size;i++){
tmp=list.get(i);
}
System.out.println("for spend;"+(System.currentTimeMills()-start));
構造一個擁有100萬數據的ArrayList和等價的LinkedList，使用以上代碼進行測試，測試結果的相對耗時如下表所示：
可以看到，最簡便的ForEach循環並沒有很好的性能表現，綜合性能不如普通的叠代器，而是用for循環通過隨機訪問遍歷列表時，ArrayList表項很好，但是LinkedList的表現卻無法讓人接受，甚至沒有辦法等待程序的結束。這是因為對LinkedList進行隨機訪問時，總會進行一次列表的遍歷操作。性能非常差，應避免使用。
（6）空間復雜度
在LinkedList中有一個私有的內部類，定義如下：
private static class Entry {
Object element;
Entry next;
Entry previous;
}
每個Entry對象reference列表中的一個元素，同時還有在LinkedList中它的上一個元素和下一個元素。一個有1000個元素的LinkedList對象將有1000個鏈接在一起的Entry對象，每個對象都對應於列表中的一個元素。這樣的話，在一個LinkedList結構中將有一個很大的空間開銷，因為它要存儲這1000個Entity對象的相關信息。
ArrayList使用一個內置的數組來存儲元素，這個數組的起始容量是10.當數組需要增長時，新的容量按如下公式獲得：新容量=(舊容量*3)/2+1，也就是說每一次容量大概會增長50%。這就意味著，如果你有一個包含大量元素的ArrayList對象，那麽最終將有很大的空間會被浪費掉，這個浪費是由ArrayList的工作方式本身造成的。如果沒有足夠的空間來存放新的元素，數組將不得不被重新進行分配以便能夠增加新的元素。對數組進行重新分配，將會導致性能急劇下降。如果我們知道一個ArrayList將會有多少個元素，我們可以通過構造方法來指定容量。我們還可以通過trimToSize方法在ArrayList分配完畢之後去掉浪費掉的空間。
（7）總結
ArrayList和LinkedList在性能上各有優缺點，都有各自所適用的地方，總的說來可以描述如下：
1．對ArrayList和LinkedList而言，在列表末尾增加一個元素所花的開銷都是固定的。對ArrayList而言，主要是在內部數組中增加一項，指向所添加的元素，偶爾可能會導致對數組重新進行分配；而對LinkedList而言，這個開銷是統一的，分配一個內部Entry對象。
2．在ArrayList的中間插入或刪除一個元素意味著這個列表中剩余的元素都會被移動；而在LinkedList的中間插入或刪除一個元素的開銷是固定的。
3．LinkedList不支持高效的隨機元素訪問。
4．ArrayList的空間浪費主要體現在在list列表的結尾預留一定的容量空間，而LinkedList的空間花費則體現在它的每一個元素都需要消耗相當的空間
可以這樣說：當操作是在一列數據的後面添加數據而不是在前面或中間,並且需要隨機地訪問其中的元素時,使用ArrayList會提供比較好的性能；當你的操作是在一列數據的前面或中間添加或刪除數據,並且按照順序訪問其中的元素時,就應該使用LinkedList了。
ArrayList和LinkedList的區別