ArrayList和LinkedList的區別

 

ArrayList和Vector使用了數組的實現,能夠認爲ArrayList或者Vector封裝了對內部數組的操做,好比向數組中添加,刪除,插入新的元素或者數據的擴展和重定向。html

LinkedList使用了循環雙向鏈表數據結構。與基於數組ArrayList相比,這是兩種大相徑庭的實現技術,這也決定了它們將適用於徹底不一樣的工做場景。數組

LinkedList鏈表由一系列表項鍊接而成。一個表項老是包含3個部分:元素內容,前驅表和後驅表,如圖所示:數據結構

在下圖展現了一個包含3個元素的LinkedList的各個表項間的鏈接關係。在JDK的實現中,不管LikedList是否爲空,鏈表內部都有一個header表項,它既表示鏈表的開始,也表示鏈表的結尾。表項header的後驅表項即是鏈表中第一個元素,表項header的前驅表項即是鏈表中最後一個元素。函數

 

下面以增長和刪除元素爲例比較ArrayList和LinkedList的不一樣之處:post

(1)增長元素到列表尾端:性能

在ArrayList中增長元素到隊列尾端的代碼以下:測試

 
public boolean add(E e){
   ensureCapacity(size+1);//確保內部數組有足夠的空間
   elementData[size++]=e;//將元素加入到數組的末尾,完成添加
   return true;      
} 

 ArrayList中add()方法的性能決定於ensureCapacity()方法。ensureCapacity()的實現以下:this

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);
}
}spa

能夠看到,只要ArrayList的當前容量足夠大,add()操做的效率很是高的。只有當ArrayList對容量的需求超出當前數組大小時,才須要進行擴容。擴容的過程當中,會進行大量的數組複製操做。而數組複製時,最終將調用System.arraycopy()方法,所以add()操做的效率仍是至關高的。3d

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進行隨機訪問時,總會進行一次列表的遍歷操做。性能很是差,應避免使用。

參考連接:https://www.cnblogs.com/sierrajuan/p/3639353.html

相關文章
相關標籤/搜索