java基礎：LinkedList — 源碼分析

其餘更多java基礎文章：
java基礎學習(目錄)

---

概述

LinkedList是一個實現了List接口和Deque接口的雙端鏈表，底層是雙向鏈表，它也能夠被看成堆棧、隊列或雙端隊列進行操做。
有關索引的操做可能從鏈表頭開始遍歷到鏈表尾部，也可能從尾部遍歷到鏈表頭部，這取決於看索引更靠近哪一端。

• LinkedList 實現 List 接口，能對它進行隊列操做。
• LinkedList 實現 Deque 接口，即能將LinkedList看成雙端隊列使用。
• LinkedList 實現了Cloneable接口，即覆蓋了函數clone()，能克隆。
• LinkedList 實現java.io.Serializable接口，這意味着LinkedList支持序列化，能經過序列化去傳輸。
• LinkedList不是線程安全的。

數據結構和基礎字段

LinkedList的底層是雙向鏈表，主要是經過Node類來構建。

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
複製代碼

內部類Node就是實際的結點，用於存放實際的元素。LinkedList經過Node類和first、last兩個特定意義的Node屬性字段，來構建雙向鏈表的底層結構。

從上圖能夠看出，LinkedList內部是一個雙端鏈表結構，有兩個變量，first指向鏈表頭部，last指向鏈表尾部。 LinkedtList內部的成員變量以下：

transient Node<E> first;
transient Node<E> last;
//LinkedList的長度
transient int size = 0;
複製代碼

方法細節

add方法

add(E e)

add(E e)用於將元素添加到鏈表尾部，實現以下:

public boolean add(E e) {
        linkLast(e);
        return true;
    }
    
    void linkLast(E e) {
        final Node<E> l = last; //保存原鏈表尾部節點
        final Node<E> newNode = new Node<>(l, e, null); //以原鏈表尾部節點爲prev節點建立一個新節點
        last = newNode; //將鏈表尾部指向新節點
        if (l == null) //若是鏈表爲空，那麼該節點既是頭節點也是尾節點
            first = newNode;
        else //鏈表不爲空，那麼將該結點做爲原鏈表尾部的後繼節點
            l.next = newNode;
        size++;
        modCount++;
    }
複製代碼

從上面代碼能夠看到，linkLast方法中就是一個鏈表尾部添加一個雙端節點的操做，可是須要注意對鏈表爲空時頭節點的處理。

add(int index,E e)

add(int index,E e)用於在指定位置添加元素。實現以下：

public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }
    
    Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) { //若是索引位置靠鏈表前半部分，從頭開始遍歷
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else { //不然，從尾開始遍歷
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }
    
    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }
複製代碼

從上面代碼能夠看到，add(int index, E element)方法主要分爲3步：

1. 檢查index的範圍，不然拋出異常
2. 若是插入位置是鏈表尾部，那麼調用linkLast方法
3. 若是插入位置是鏈表中間，那麼調用linkBefore方法

node(int index)方法就比較簡單，根據index是靠近頭部仍是尾部選擇不一樣的遍歷方向。

linkBefore(E e, Node succ)方法表示在succ節點前插入一個值爲e的新節點，步驟以下：

1. 將succ節點的前驅節點保存爲pred
2. 建立newNode節點，將newNode的後繼指針指向succ，前驅指針指向pred
3. 將succ的前驅指針指向newNode
4. 根據pred是否爲null，進行不一樣操做。

• 若是pred爲null，說明該節點插入在頭節點以前，要重置first頭節點
• 若是pred不爲null，那麼直接將pred的後繼指針指向newNode便可

addAll方法

public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }
    
    //將集合從指定位置開始插入
    public boolean addAll(int index, Collection<? extends E> c) {
        //Step 1:檢查index範圍
        checkPositionIndex(index);

        //Step 2:獲得集合的數據
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

        //Step 3：獲得插入位置的前驅節點和後繼節點
        Node<E> pred, succ;
        //若是插入位置爲尾部，前驅節點爲last，後繼節點爲null
        if (index == size) {
            succ = null;
            pred = last;
        }
        //不然，調用node()方法獲得後繼節點，再獲得前驅節點
        else {
            succ = node(index);
            pred = succ.prev;
        }

        //Step 4：遍歷數據將數據插入
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            //建立新節點
            Node<E> newNode = new Node<>(pred, e, null);
            //若是插入位置在鏈表頭部
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }

        //若是插入位置在尾部，重置last節點
        if (succ == null) {
            last = pred;
        }
        //不然，將插入的鏈表與先前鏈表鏈接起來
        else {
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;
        modCount++;
        return true;
    }
複製代碼

從上面的代碼能夠看到，addAll方法主要分爲4步：

1. 檢查index索引範圍
2. 獲得集合數據
3. 獲得插入位置的前驅和後繼節點
4. 遍歷數據，將數據插入到指定位置

remove方法

//刪：remove目標節點
    public E remove(int index) {
        checkElementIndex(index);//檢查是否越界 下標[0,size)
        return unlink(node(index));//從鏈表上刪除某節點
    }

    //由於要考慮 null元素，也是分狀況遍歷
    public boolean remove(Object o) {
        if (o == null) {//若是要刪除的是null節點(從remove和add 裏 能夠看出，容許元素爲null)
            //遍歷每一個節點 對比
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
    
    //將節點x，從鏈表中刪除,返回刪除節點的值
    E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;//繼續元素值，供返回
        final Node<E> next = x.next;//保存當前節點的後置節點
        final Node<E> prev = x.prev;//前置節點

        if (prev == null) {//前置節點爲null，
            first = next;//則首節點爲next
        } else {//不然 更新前置節點的後置節點
            prev.next = next;
            x.prev = null;//記得將要刪除節點的前置節點置null
        }
        //若是後置節點爲null，說明是尾節點
        if (next == null) {
            last = prev;
        } else {//不然更新 後置節點的前置節點
            next.prev = prev;
            x.next = null;//記得刪除節點的後置節點爲null
        }
        //將刪除節點的元素值置null，以便GC
        x.item = null;
        size--;//修改size
        modCount++;//修改modCount
        return element;//返回刪除的元素值
    }
複製代碼

上面unlink方法的代碼能夠簡單分爲如下幾個步驟：
第一步：獲得待刪除節點的前驅節點和後繼節點
第二步：更新前驅節點和刪除節點的prev
第三步：更新後繼節點和刪除節點的next
第四步：將刪除節點的元素值置null，以便GC，修改size值
通過四步，待刪除的結點就從鏈表中脫離了。須要注意的是刪除位置是頭節點或尾節點時候的處理。

Deque接口的方法

Deque 是 Double ended queue (雙端隊列) 的縮寫,讀音和 deck 同樣，蛋殼。
Deque接口其具體方法的處理邏輯以下所示：

	頭部訪問		尾部訪問
操做	拋出異常	返回特殊值	拋出異常	返回特殊值
插入操做	addFirst(e)	offerFirst(e)	addLast(e)	offerLast(e)
刪除操做	removeFirst()	pollFirst()	removeLast()	pollLast()
訪問操做	getFirst()	peekFirst()	getLast()	peekLast()

在LinkedList中，返回的特殊值爲null或true。舉兩個簡單的例子分析下：

public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }
    
    public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
     }
複製代碼

很簡單，當first爲null時，getFirst()拋出異常，peekFirst()返回特殊值null。

public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }
    
    public void addFirst(E e) {
        linkFirst(e);
    }
複製代碼

offerFirst方法返回true，addFirst方法無返回。

Deque 接口可以當作隊列（先進先出）、棧（後進先出）使用，具體就不在這闡述，能夠看java.util.Deque學習筆記

總結

• LinkedList 是雙向列表，能存儲null值
• 鏈表批量增長，是靠for循環遍歷原數組，依次執行插入節點操做。對比ArrayList是經過System.arraycopy完成批量增長的。增長必定會修改modCount。
• 經過下標獲取某個node 的時候，會根據index處於前半段仍是後半段 進行一個折半，以提高查詢效率
• 刪也必定會修改modCount。 按下標刪，也是先根據index找到Node，而後去鏈表上unlink掉這個Node。 按元素刪，會先去遍歷鏈表尋找是否有該Node，若是有，去鏈表上unlink掉這個Node。
• 改也是先根據index找到Node，而後替換值。改不修改modCount。
• 查自己就是根據index找到Node。
• LinkedList不光可以向前迭代，還能像後迭代，不光能當鏈表，還能當隊列、棧使用