前言

今天來介紹下LinkedList，在集合框架整體框架一章中，我們介紹了List接口，LinkedList與ArrayList一樣實現List接口，只是ArrayList是List接口的大小可變數組的實現，LinkedList是List接口鏈表的實現?；阪湵韺崿F的方式使得LinkedList在插入和刪除時更優于ArrayList，而隨機訪問則比ArrayList遜色些。
構造圖如下:
藍色線條：繼承
綠色線條：接口實現

正文

LinkedList是基于鏈表結構的一種List，在分析LinkedList源碼前有必要對鏈表結構進行說明。

1.鏈表的概念
鏈表是由一系列非連續的節點組成的存儲結構，簡單分下類的話，鏈表又分為單向鏈表和雙向鏈表，而單向/雙向鏈表又可以分為循環鏈表和非循環鏈表，下面簡單就這四種鏈表進行圖解說明。

1.1.單向鏈表
單向鏈表就是通過每個結點的指針指向下一個結點從而鏈接起來的結構，最后一個節點的next指向null。

1.2.單向循環鏈表
單向循環鏈表和單向列表的不同是，最后一個節點的next不是指向null，而是指向head節點，形成一個“環”。

1.3.雙向鏈表
從名字就可以看出，雙向鏈表是包含兩個指針的，pre指向前一個節點，next指向后一個節點，但是第一個節點head的pre指向null，最后一個節點的tail指向null。

1.4.雙向循環鏈表
雙向循環鏈表和雙向鏈表的不同在于，第一個節點的pre指向最后一個節點，最后一個節點的next指向第一個節點，也形成一個“環”。而LinkedList就是基于雙向循環鏈表設計的。

更形象的解釋下就是：雙向循環鏈表就像一群小孩手牽手圍成一個圈，第一個小孩的右手拉著第二個小孩的左手，第二個小孩的左手拉著第一個小孩的右手。。。最后一個小孩的右手拉著第一個小孩的左手。

ok，鏈表的概念介紹完了，下面進入寫注釋和源碼分析部分，但是在這之前還是要提醒一句，不是啰嗦哦，鏈表操作理解起來比數組困難了不少，所以務必要理解上面的圖解，如果源碼解析過程中遇到理解困難，請返回來照圖理解。

LinkedList簡介

LinkedList定義

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

LinkedList 是一個繼承于AbstractSequentialList的雙向循環鏈表。它也可以被當作堆棧、隊列或雙端隊列進行操作。
LinkedList 實現 List 接口，能對它進行隊列操作。
LinkedList 實現 Deque 接口，即能將LinkedList當作雙端隊列使用。
LinkedList 實現了Cloneable接口，即覆蓋了函數clone()，能克隆。
LinkedList 實現java.io.Serializable接口，這意味著LinkedList支持序列化，能通過序列化去傳輸。
LinkedList 是非同步的。

LinkedList屬性

明白了上面的鏈表概念，以及LinkedList是基于雙向循環鏈表設計的，下面在具體來看看LinkedList的底層的屬性

private transient Entry<E> header = new Entry<E>(null, null, null);
2 private transient int size = 0;

LinkedList中提供了上面兩個屬性，其中size和ArrayList中一樣用來計數，表示list的元素數量，而header則是鏈表的頭結點，Entry則是鏈表的節點對象。

private static class Entry<E> {
    E element;  // 當前存儲元素
    Entry<E> next;  // 下一個元素節點
    Entry<E> previous;  // 上一個元素節點
    Entry(E element, Entry<E> next, Entry<E> previous) {
        this.element = element;
        this.next = next;
        this.previous = previous;
    }
}

Entry為LinkedList 的內部類，其中定義了當前存儲的元素，以及該元素的上一個元素和下一個元素。結合上面雙向鏈表的示意圖很容易看懂。

LinkedList構造函數

/**
* 構造一個空的LinkedList .
*/
public LinkedList() {
    //將header節點的前一節點和后一節點都設置為自身
    header.next = header. previous = header ;
}

/**
* 構造一個包含指定 collection 中的元素的列表，這些元素按其 collection 的迭代器返回的順序排列
*/
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

需要注意的是空的LinkedList構造方法，它將header節點的前一節點和后一節點都設置為自身，這里便說明LinkedList 是一個雙向循環鏈表，如果只是單存的雙向鏈表而不是循環鏈表，他的實現應該是這樣的：

public LinkedList() {
    header.next = null;
    header. previous = null;
}

非循環鏈表的情況應該是header節點的前一節點和后一節點均為null（參見鏈表圖解）。

API方法摘要

LinkedList源碼解析(基于JDK1.6.0_45)

增加

增加方法的代碼讀起來比較不容易理解，需要的時候請結合鏈表圖解。

/**
 * 將一個元素添加至list尾部
 */
public boolean add(E e) {
   // 在header前添加元素e，header前就是最后一個結點啦，就是在最后一個結點的后面添加元素e
   addBefore(e, header);
    return true;
}
/**
 * 在指定位置添加元素
 */
public void add(int index, E element) {
    // 如果index等于list元素個數，則在隊尾添加元素(header之前)，否則在index節點前添加元素
    addBefore(element, (index== size ? header : entry(index)));
}
 
private Entry<E> addBefore(E e, Entry<E> entry) {
    // 用entry創建一個要添加的新節點，next為entry，previous為entry.previous，意思就是新節點插入entry前面，確定自身的前后引用，
    Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
     // 下面修改newEntry的前后節點的引用，確保其鏈表的引用關系是正確的
    // 將上一個節點的next指向自己
    newEntry. previous.next = newEntry;
    // 將下一個節點的previous指向自己
    newEntry. next.previous = newEntry;
    // 計數+1
     size++;
     modCount++;
     return newEntry;
}

到這里可以發現一點疑慮，header作為雙向循環鏈表的頭結點是不保存數據的，也就是說hedaer中的element永遠等于null。

/**
 * 添加一個集合元素到list中
 */
public boolean addAll(Collection<? extends E> c) {
        // 將集合元素添加到list最后的尾部
    return addAll(size , c);
}

/**
 * 在指定位置添加一個集合元素到list中
 */
public boolean addAll(int index, Collection<? extends E> c) {
    // 越界檢查
    if (index < 0 || index > size)
        throw new IndexOutOfBoundsException( "Index: "+index+
                                            ", Size: "+size );
    Object[] a = c.toArray();
    // 要插入元素的個數
    int numNew = a.length ;
    if (numNew==0)
        return false;
    modCount++;

    // 找出要插入元素的前后節點
    // 獲取要插入index位置的下一個節點，如果index正好是lsit尾部的位置那么下一個節點就是header，否則需要查找index位置的節點
    Entry<E> successor = (index== size ? header : entry(index));
    // 獲取要插入index位置的上一個節點，因為是插入，所以上一個點擊就是未插入前下一個節點的上一個
    Entry<E> predecessor = successor. previous;
    // 循環插入
    for (int i=0; i<numNew; i++) {
        // 構造一個節點，確認自身的前后引用
        Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
        // 將插入位置上一個節點的下一個元素引用指向當前元素（這里不修改下一個節點的上一個元素引用，是因為下一個節點隨著循環一直在變）
        predecessor. next = e;
        // 最后修改插入位置的上一個節點為自身，這里主要是為了下次遍歷后續元素插入在當前節點的后面，確保這些元素本身的順序
        predecessor = e;
    }
    // 遍歷完所有元素，最后修改下一個節點的上一個元素引用為遍歷的最后一個元素
    successor. previous = predecessor;

    // 修改計數器
    size += numNew;
    return true;
}

其實刪除也是一樣的對不對？下面看看刪除方法的實現。

刪除

/**
 * 刪除第一個匹配的指定元素
 */
public boolean remove(Object o) {
     // 遍歷鏈表找到要被刪除的節點
    if (o==null) {
        for (Entry<E> e = header .next; e != header; e = e.next ) {
            if (e.element ==null) {
                remove(e);
                return true;
            }
        }
    } else {
        for (Entry<E> e = header .next; e != header; e = e.next ) {
            if (o.equals(e.element )) {
                remove(e);
                return true;
            }
        }
    }
    return false;
}

private E remove(Entry<E> e) {
    if (e == header )
       throw new NoSuchElementException();

   // 被刪除的元素，供返回
    E result = e. element;
   // 下面修正前后對該節點的引用
   // 將該節點的上一個節點的next指向該節點的下一個節點
   e. previous.next = e.next;
   // 將該節點的下一個節點的previous指向該節點的上一個節點
   e. next.previous = e.previous;
   // 修正該節點自身的前后引用
    e. next = e.previous = null;
   // 將自身置空，讓gc可以盡快回收
    e. element = null;
   // 計數器減一
    size--;
    modCount++;
    return result;
}

上面對于鏈表增加元素總結了，一句話就是“改變前后的互相指向關系”，刪除也是同樣的道理，由于節點被刪除，該節點的上一個節點和下一個節點互相拉一下小手就可以了，注意的是“互相”，不能一廂情愿。

修改

/**
 * 修改指定位置索引位置的元素
 */
public E set( int index, E element) {
    // 查找index位置的節點
    Entry<E> e = entry(index);
    // 取出該節點的元素，供返回使用
    E oldVal = e. element;
    // 用新元素替換舊元素
    e. element = element;
    // 返回舊元素
    return oldVal;
}    

set方法看起來簡單了很多，只要修改該節點上的元素就好了，但是不要忽略了這里的entry()方法，重點就是它。

查詢

終于到查詢了，終于發現了上面經常出現的那個方法entry()根據index查詢節點，我們知道數組是有下標的，通過下標操作天然的支持根據index查詢元素，而鏈表中是沒有index概念呢，那么怎么樣才能通過index查詢到對應的元素呢，下面就來看看LinkedList是怎么實現的。

/**
 * 查找指定索引位置的元素
 */
public E get( int index) {
    return entry(index).element ;
}

/**
 * 返回指定索引位置的節點
 */
private Entry<E> entry( int index) {
    // 越界檢查
    if (index < 0 || index >= size)
        throw new IndexOutOfBoundsException( "Index: "+index+
                                            ", Size: "+size );
    // 取出頭結點
    Entry<E> e = header;
    // size>>1右移一位代表除以2，這里使用簡單的二分方法，判斷index與list的中間位置的距離
    if (index < (size >> 1)) {
        // 如果index距離list中間位置較近，則從頭部向后遍歷(next)
        for (int i = 0; i <= index; i++)
            e = e. next;
    } else {
        // 如果index距離list中間位置較遠，則從頭部向前遍歷(previous)
        for (int i = size; i > index; i--)
            e = e. previous;
    }
    return e;
}

現在知道了，LinkedList是通過從header開始index計為0，然后一直往下遍歷（next），直到到底index位置。為了優化查詢效率，LinkedList采用了二分查找（這里說的二分只是簡單的一次二分），判斷index與size中間位置的距離，采取從header向后還是向前查找。
到這里我們明白，基于雙向循環鏈表實現的LinkedList，通過索引Index的操作時低效的，index所對應的元素越靠近中間所費時間越長。而向鏈表兩端插入和刪除元素則是非常高效的（如果不是兩端的話，都需要對鏈表進行遍歷查找）。

是否包含

// 判斷LinkedList是否包含元素(o)
public boolean contains(Object o) {
    return indexOf(o) != -1;
}

// 從前向后查找，返回“值為對象(o)的節點對應的索引”
// 不存在就返回-1
public int indexOf(Object o) {
    int index = 0;
    if (o==null) {
        for (Entry e = header .next; e != header; e = e.next ) {
            if (e.element ==null)
                return index;
            index++;
        }
    } else {
        for (Entry e = header .next; e != header; e = e.next ) {
            if (o.equals(e.element ))
                return index;
            index++;
        }
    }
    return -1;
}

// 從后向前查找，返回“值為對象(o)的節點對應的索引”
// 不存在就返回-1
public int lastIndexOf(Object o) {
    int index = size ;
    if (o==null) {
        for (Entry e = header .previous; e != header; e = e.previous ) {
            index--;
            if (e.element ==null)
                return index;
        }
    } else {
        for (Entry e = header .previous; e != header; e = e.previous ) {
            index--;
            if (o.equals(e.element ))
                return index;
        }
    }
    return -1;
}

和public boolean remove(Object o) 一樣，indexOf查詢元素位于容器的索引位置，都是需要對鏈表進行遍歷操作，當然也就是低效了啦。

判斷容量

/**
 * Returns the number of elements in this list.
 *
 * @return the number of elements in this list
 */
public int size() {
    return size ;
}

/**
 * {@inheritDoc}
 *
 * <p>This implementation returns <tt>size() == 0 </tt>.
 */
public boolean isEmpty() {
    return size() == 0;
}

和ArrayList一樣，基于計數器size操作，容量判斷很方便。
到這里LinkedList就分析完了，不對好像還差些什么對不對？是什么呢，就是最開始說的Deque雙端隊列，明白了鏈表原理和LinkedList的基本crud操作，Deque的LinkedList實現就已經是so easy了，我們簡單看下。

LinkedList實現的Deque雙端隊列

/**
 * Adds the specified element as the tail (last element) of this list.
 *
 * @param e the element to add
 * @return <tt> true</tt> (as specified by {@link Queue#offer})
 * @since 1.5
 */
public boolean offer(E e) {
    return add(e);
}

/**
 * Retrieves and removes the head (first element) of this list
 * @return the head of this list, or <tt>null </tt> if this list is empty
 * @since 1.5
 */
public E poll() {
    if (size ==0)
        return null;
    return removeFirst();
}

/**
 * Removes and returns the first element from this list.
 *
 * @return the first element from this list
 * @throws NoSuchElementException if this list is empty
 */
public E removeFirst() {
    return remove(header .next);
}

/**
 * Retrieves, but does not remove, the head (first element) of this list.
 * @return the head of this list, or <tt>null </tt> if this list is empty
 * @since 1.5
 */
public E peek() {
    if (size ==0)
        return null;
    return getFirst();
}

/**
 * Returns the first element in this list.
 *
 * @return the first element in this list
 * @throws NoSuchElementException if this list is empty
 */
public E getFirst() {
    if (size ==0)
       throw new NoSuchElementException();

    return header .next. element;
}

/**
 * Pushes an element onto the stack represented by this list.  In other
 * words, inserts the element at the front of this list.
 *
 * <p>This method is equivalent to {@link #addFirst}.
 *
 * @param e the element to push
 * @since 1.6
 */
public void push(E e) {
    addFirst(e);
}

/**
 * Inserts the specified element at the beginning of this list.
 *
 * @param e the element to add
 */
public void addFirst(E e) {
   addBefore(e, header.next );
}

看看Deque 的實現是不是很簡單，邏輯都是基于上面講的鏈表操作的，對于隊列的一些概念我不打算在這里講，是因為后面隊列會單獨拿出來分析啦，這里只要理解基于鏈表實現的list內部是怎么操作的就可以啦。

總結：
(01) LinkedList 實際上是通過雙向鏈表去實現的。
它包含一個非常重要的內部類：Entry。Entry是雙向鏈表節點所對應的數據結構，它包括的屬性有：當前節點所包含的值，上一個節點，下一個節點。
(02) 從LinkedList的實現方式中可以發現，它不存在LinkedList容量不足的問題。
(03) LinkedList的克隆函數，即是將全部元素克隆到一個新的LinkedList對象中。
(04) LinkedList實現java.io.Serializable。當寫入到輸出流時，先寫入“容量”，再依次寫入“每一個節點保護的值”；當讀出輸入流時，先讀取“容量”，再依次讀取“每一個元素”。
(05) 由于LinkedList實現了Deque，而Deque接口定義了在雙端隊列兩端訪問元素的方法。提供插入、移除和檢查元素的方法。每種方法都存在兩種形式：一種形式在操作失敗時拋出異常，另一種形式返回一個特殊值（null 或 false，具體取決于操作）。

對LinkedList以及ArrayList的迭代效率比較

先說結論：ArrayList使用最普通的for循環遍歷比較快，LinkedList使用foreach循環比較快。

看一下兩個List的定義：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

注意到ArrayList是實現了RandomAccess接口而LinkedList則沒有實現這個接口，關于RandomAccess這個接口的作用，看一下JDK API上的說法：

為此，我寫一段代碼證明一下這一點，注意，雖然上面的例子用的Iterator，但是做foreach循環的時候，編譯器默認會使用這個集合的Iterator。測試代碼如下：

public class TestMain
{
    private static int SIZE = 111111;
    
    private static void loopList(List<Integer> list)
    {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++)
        {
            list.get(i);
        }
        System.out.println(list.getClass().getSimpleName() + "使用普通for循環遍歷時間為" + 
                (System.currentTimeMillis() - startTime) + "ms");
        
        startTime = System.currentTimeMillis();
        for (Integer i : list)
        {
            
        }
        System.out.println(list.getClass().getSimpleName() + "使用foreach循環遍歷時間為" + 
                (System.currentTimeMillis() - startTime) + "ms");
    }
    
    public static void main(String[] args)
    {
        List<Integer> arrayList = new ArrayList<Integer>(SIZE);
        List<Integer> linkedList = new LinkedList<Integer>();
        
        for (int i = 0; i < SIZE; i++)
        {
            arrayList.add(i);
            linkedList.add(i);
        }
        
        loopList(arrayList);
        loopList(linkedList);
        System.out.println();
    }
}

我截取三次運行結果：

ArrayList使用普通for循環遍歷時間為10ms
ArrayList使用foreach循環遍歷時間為36ms
LinkedList使用普通for循環遍歷時間為21841ms
LinkedList使用foreach循環遍歷時間為34ms

ArrayList使用普通for循環遍歷時間為11ms
ArrayList使用foreach循環遍歷時間為27ms
LinkedList使用普通for循環遍歷時間為20500ms
LinkedList使用foreach循環遍歷時間為27ms

ArrayList使用普通for循環遍歷時間為10ms
ArrayList使用foreach循環遍歷時間為22ms
LinkedList使用普通for循環遍歷時間為20237ms
LinkedList使用foreach循環遍歷時間為38ms

有了JDK API的解釋，這個結果并不讓人感到意外，最最想要提出的一點是：如果使用普通for循環遍歷LinkedList，其遍歷速度將慢得令人發指。

總結

ArrayList和LinkedList的比較

1、順序插入速度ArrayList會比較快，因為ArrayList是基于數組實現的，數組是事先new好的，只要往指定位置塞一個數據就好了；LinkedList則不同，每次順序插入的時候LinkedList將new一個對象出來，如果對象比較大，那么new的時間勢必會長一點，再加上一些引用賦值的操作，所以順序插入LinkedList必然慢于ArrayList

2、基于上一點，因為LinkedList里面不僅維護了待插入的元素，還維護了Entry的前置Entry和后繼Entry，如果一個LinkedList中的Entry非常多，那么LinkedList將比ArrayList更耗費一些內存

3、數據遍歷的速度，看最后一部分，這里就不細講了，結論是：使用各自遍歷效率最高的方式，ArrayList的遍歷效率會比LinkedList的遍歷效率高一些

4、有些說法認為LinkedList做插入和刪除更快，這種說法其實是不準確的：

（1）LinkedList做插入、刪除的時候，慢在尋址，快在只需要改變前后Entry的引用地址

（2）ArrayList做插入、刪除的時候，慢在數組元素的批量copy，快在尋址

所以，如果待插入、刪除的元素是在數據結構的前半段尤其是非常靠前的位置的時候，LinkedList的效率將大大快過ArrayList，因為ArrayList將批量copy大量的元素；越往后，對于LinkedList來說，因為它是雙向鏈表，所以在第2個元素后面插入一個數據和在倒數第2個元素后面插入一個元素在效率上基本沒有差別，但是ArrayList由于要批量copy的元素越來越少，操作速度必然追上乃至超過LinkedList。

從這個分析看出，如果你十分確定你插入、刪除的元素是在前半段，那么就使用LinkedList；如果你十分確定你刪除、刪除的元素在比較靠后的位置，那么可以考慮使用ArrayList。如果你不能確定你要做的插入、刪除是在哪兒呢？那還是建議你使用LinkedList吧，因為一來LinkedList整體插入、刪除的執行效率比較穩定，沒有ArrayList這種越往后越快的情況；二來插入元素的時候，弄得不好ArrayList就要進行一次擴容，記住，ArrayList底層數組擴容是一個既消耗時間又消耗空間的操作。

參考

該文為本人學習的筆記，方便以后自己跳槽前復習。參考網上各大帖子，取其精華整合自己的理解而成。集合框架源碼面試經常會問，所以解讀源碼十分必要,希望對你有用。
java提高篇（二三）-----HashMap
Java 集合系列10之 HashMap詳細介紹(源碼解析)和使用示例
圖解集合4：HashMap

整理的集合框架思維導圖

個人整理的Java集合框架思維導圖，動態維護。導出的圖片無法查看備注的一些信息，所以需要源文件的童鞋可以關注我個人主頁上的公眾號，回復Java集合框架即可獲取源文件。

一直覺得自己寫的不是技術，而是情懷，一篇篇文章是自己這一路走來的痕跡。靠專業技能的成功是最具可復制性的，希望我的這條路能讓你少走彎路，希望我能幫你抹去知識的蒙塵，希望我能幫你理清知識的脈絡，希望未來技術之巔上有你也有我。