ArrayList和linkedList的區別

轉自：https://www.cnblogs.com/sierrajuan/p/3639353.html

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)   //如果新容量小於最小需要的容量，則使用最小                                                    //需要的容量大小         newCapacity=minCapacity ;  //進行擴容的數組複製         elementData=Arrays.copyof(elementData,newCapacity);  }}

可以看到，只要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進行隨機訪問時，總會進行一次列表的遍曆操作。效能非常差，應避免使用。