Java LinkedList的實現原理

LinkedList是Java List類型的集合類的一種實現，此外，LinkedList還實現了Deque接口。本文基於Java1.8，對於LinkedList的實現原理做一下詳細講解。

（Java1.8源碼：http://docs.oracle.com/javase/8/docs/api/）

 

一、LinkedList實現原理總結

 

LinkedList的實現原理總結如下：

 

①數據存儲是基於雙向鏈表實現的。

②插入數據很快。先是在雙向鏈表中找到要插入節點的位置index，找到之后，再插入一個新節點。 雙向鏈表查找index位置的節點時，有一個加速動作：若index < 雙向鏈表長度的1/2，則從前向后查找; 否則，從后向前查找。

③刪除數據很快。先是在雙向鏈表中找到要插入節點的位置index，找到之后，進行如下操作：node.previous.next = node.next;node.next.previous = node.previous;node = null 。查找節點過程和插入一樣。

④獲取數據很慢，需要從Head節點進行查找。

⑤遍歷數據很慢，每次獲取數據都需要從頭開始。

 

二、ArrayList的實現原理詳解

 

（轉自：http://tan4836128.iteye.com/blog/1717809）

1. LinkedList概述：

List 接口的鏈接列表實現。實現所有可選的列表操作，並且允許所有元素（包括 null）。除了實現 List 接口外，LinkedList 類還為在列表的開頭及結尾 get、remove 和 insert 元素提供了統一的命名方法。這些操作允許將鏈接列表用作堆棧、隊列或雙端隊列。

此類實現 Deque 接口，為 add、poll 提供先進先出隊列操作，以及其他堆棧和雙端隊列操作。

所有操作都是按照雙重鏈接列表的需要執行的。在列表中編索引的操作將從開頭或結尾遍歷列表（從靠近指定索引的一端）。

注意，此實現不是同步的。如果多個線程同時訪問一個鏈接列表，而其中至少一個線程從結構上修改了該列表，則它必須 保持外部同步。（結構修改指添加或刪除一個或多個元素的任何操作；僅設置元素的值不是結構修改。）這一般通過對自然封裝該列表的對象進行同步操作來完成。如果不存在這樣的對象，則應該使用 Collections.synchronizedList 方法來“包裝”該列表。最好在創建時完成這一操作，以防止對列表進行意外的不同步訪問，如下所示：

                    List list = Collections.synchronizedList(new LinkedList(...));

此類的 iterator 和 listIterator 方法返回的迭代器是快速失敗 的：在迭代器創建之后，如果從結構上對列表進行修改，除非通過迭代器自身的 remove 或 add 方法，其他任何時間任何方式的修改，迭代器都將拋出 ConcurrentModificationException。因此，面對並發的修改，迭代器很快就會完全失敗，而不冒將來不確定的時間任意發生不確定行為的風險。

注意，迭代器的快速失敗行為不能得到保證，一般來說，存在不同步的並發修改時，不可能作出任何硬性保證。快速失敗迭代器盡最大努力拋出 ConcurrentModificationException。因此，編寫依賴於此異常的程序的方式是錯誤的，正確做法是：迭代器的快速失敗行為應該僅用於檢測程序錯誤。

 

2. LinkedList的實現：

Java代碼  

1. private transient Entry<E> header = new Entry<E>(null, null, null);   

 

 這個成員變量是LinkedList的關鍵，它在鏈表中沒有實際數據意義，是鏈表的標示（通俗一點就是鏈表的第一個無意義的元素），而且被修飾為transient，標示着他不會被序列化。header也可以當做隊列末尾的元素，因為是雙向列表，所以header.next末尾元素后邊的元素就成了隊首元素，header.previous就是隊尾元素了，看一下它的添加方法

 

Java代碼  

1. public void addFirst(E paramE) {  
2.     addBefore(paramE, this.header.next);//隊首  
3. }  
4. public void addLast(E paramE) {  
5.     addBefore(paramE, this.header);//隊尾  
6. }  

 以上兩個方法都利用addBefore方法將元素添加到指定對象之前，

 

 addFirst向隊頭加元素，將元素paramE添加到header.next-隊首元素之前；

 addLast向隊尾加元素，將元素paramE添加到header之前；

 

         再看一下addBefore(E e,Entry<E> entry)函數

 

Java代碼  

1. /*** 
2.  * 要添加的元素：paramE 
3.  * 目標對象：paramEntry 
4.  */  
5. private Entry<E> addBefore(E paramE, Entry<E> paramEntry)  
6. {  
7.     //要添加的對象  
8.     Entry localEntry = new Entry(paramE, paramEntry, paramEntry.previous);  
9.     /*** 
10.      * localEntry.previous = paramEntry.previous 
11.      * 目標對象的前一元素的后一元素（localEntry.previous.next）設置為要添加的對象 
12.      */  
13.     localEntry.previous.next = localEntry;  
14.     /*** 
15.      * localEntry.next = paramEntry 
16.      * 目標對象的前一元素（localEntry.next.previous）設置為要添加的對象 
17.      */  
18.     localEntry.next.previous = localEntry;  
19.     this.size += 1;  
20.     this.modCount += 1;  
21.     return localEntry;  
22. }  

 

鏈表的基本特性是插入速度快，遍歷速度慢，下面兩個方法可以反映這個特點

 

Java代碼  

1. public int indexOf(Object paramObject) {  
2.     int i = 0;  
3.     Entry localEntry;  
4.     /*** 
5.      * 遍歷規則：從頭到尾，序列呈升序狀態 
6.      */  
7.     if (paramObject == null)  
8.         for (localEntry = this.header.next; localEntry != this.header; localEntry = localEntry.next) {  
9.             if (localEntry.element == null)  
10.                 return i;  
11.             i++;  
12.         }  
13.     else {  
14.         for (localEntry = this.header.next; localEntry != this.header; localEntry = localEntry.next) {  
15.             if (paramObject.equals(localEntry.element))  
16.                 return i;  
17.             i++;  
18.         }  
19.     }  
20.     return -1;  
21. }  
22. public int lastIndexOf(Object paramObject) {  
23.     int i = this.size;  
24.     Entry localEntry;  
25.     /*** 
26.      * 遍歷規則：從尾到頭，序列呈降序狀態 
27.      */  
28.     if (paramObject == null) {  
29.         for (localEntry = this.header.previous; localEntry != this.header; localEntry = localEntry.previous) {  
30.             i--;  
31.             if (localEntry.element == null)  
32.                 return i;  
33.             }  
34.     }else {  
35.         for (localEntry = this.header.previous; localEntry != this.header; localEntry = localEntry.previous) {  
36.             i--;  
37.             if (paramObject.equals(localEntry.element))  
38.                 return i;  
39.         }  
40.     }  
41.     return -1;  
42. }  

 值得注意的是，鏈表插入數據速度快的說法是相對的，在數據量很小的時候，ArrayList的插入速度不僅不比LinkedList慢，而且還快很多（本文不作介紹，讀者可自行測試），只有當數據量達到一定量，這個特性才會體現出來，這需要開發者明確需求場景

LinkedList的方法entry(int index)類似ArrayList的get(int index)

 

Java代碼  

1. /*** 
2.  * 根據序號獲取Entry對象 
3.  */  
4. private Entry<E> entry(int paramInt) {  
5.     if ((paramInt < 0) || (paramInt >= this.size)) {  
6.         throw new IndexOutOfBoundsException("Index: " + paramInt + ", Size: " + this.size);  
7.     }  
8.     Entry localEntry = this.header;  
9.     int i;  
10.     /*** 
11.      * 二分法：目標序號小於Size的1/2，則從頭到尾 
12.      *             如果大於Size的1/2，則從尾到頭 
13.      */  
14.     if (paramInt < this.size >> 1) {  
15.         for (i = 0; i <= paramInt; i++)  
16.             localEntry = localEntry.next;  
17.     } else {  
18.         for (i = this.size; i > paramInt; i--)  
19.             localEntry = localEntry.previous;  
20.     }  
21.     return localEntry;  
22. }  

LinkedList還提供了降序迭代器，如下

 

Java代碼  

1. public Iterator<E> descendingIterator()   {  
2.         return new DescendingIterator(null);  
3.     }  

 

關於降序迭代的具體實現可以看看源碼，很簡單

LinkedList是針對鏈表操作的一個比較全的實現，對於頻繁的數據插入有較高效率，研究其具體實現可更有利於准確的使用它。該類的toArray、clone以及其他一些方法很值得參考。

 

3. LinkedList.Entry

LinkedList的內部類Entry是實現Deque接口的基本操作單元，其結構如下：

 

Java代碼  

1. private static class Entry<E>  
2. {  
3.     E element;  
4.     Entry<E> next;  
5.     Entry<E> previous;  
6.     /*** 
7.      * 構造方法：目標對象paramE將被放置在paramEntry1之前，paramEntry2之后 
8.      */  
9.     Entry(E paramE, Entry<E> paramEntry1, Entry<E> paramEntry2)  
10.     {  
11.         this.element = paramE;  
12.         this.next = paramEntry1;  
13.         this.previous = paramEntry2;  
14.     }  
15. }  

4. 內部迭代器：ListItr

雖然上層父類AbstractList<E>已經實現了迭代器，但LinkedList的直接父類AbstractSequentialList<E>給子類重新定義個一個需要實現的迭代器的抽象方法，代碼如下：

 

Java代碼  

1. public abstract class AbstractSequentialList<E> extends AbstractList<E> {  
2.     /*** 
3.      * 返回子類實現的迭代器 
4.      */  
5.     public Iterator<E> iterator() {  
6.         return listIterator();  
7.     }  
8.     public abstract ListIterator<E> listIterator(int paramInt);  
9. }  

 

此處實現的迭代器內部機制跟AbstractList基本一致，可以看看源碼

此類的迭代器的實現機制可以通過ListItr的remove方法來分析，同時也可分析Java對雙端隊列的處理辦法

 

Java代碼  

1. /*** 
2.  * 當前指針位置：this.next 
3.  * 當前所操作的對象：this.lastReturned 
4.  */  
5. public void remove() {  
6.     checkForComodification();  
7.     LinkedList.Entry localEntry = this.lastReturned.next;  
8.     try {  
9.         LinkedList.this.remove(this.lastReturned);  
10.     } catch (NoSuchElementException localNoSuchElementException) {  
11.         throw new IllegalStateException();  
12.     }  
13.     /*** 
14.      * 當鏈表的size為0，指針會指向this.header，其他方法（如set方法）將以此判斷當前操作對象的狀態 
15.      */  
16.     if (this.next == this.lastReturned)  
17.         this.next = localEntry;  
18.     else  
19.         this.nextIndex -= 1;  
20.     /*** 
21.      * 調用LinkedList.this.remove(E)之后 
22.      * 當前操作對象this.lastReturned指向的對象被設置為this.header（原對象為null） 
23.      * 指針移動到this.lastReturned.next 
24.      */  
25.     this.lastReturned = LinkedList.this.header;  
26.     //修改次數加1  
27.     this.expectedModCount += 1;  
28. }