Java之LinkedList源碼淺析

LinkedList

• 優勢：插入、刪除元素效率高
• 缺點：遍歷數據效率低。

本文基於JDK1.8.131的源碼分析（其餘版本的源碼，不作表述）。

數據結構

底層實現，雙向鏈表

1.構造方法

構造方法以及涉及到的方法：

transient int size = 0;
transient Node<E> first;
transient Node<E> last;
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}
public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
    checkPositionIndex(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;

    Node<E> pred, succ;
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        succ = node(index);
        pred = succ.prev;
    }

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

    if (succ == null) {
        last = pred;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }

    size += numNew;
    modCount++;
    return true;
}
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;
    }
}

與ArrayList不一樣，LinkedList有兩個構造方法，一個無參，一個是傳入一個集合的參數。無參的沒有初始化什麼東西；傳入集合參數的構造方法，裏面使用addAll方法將參數添加到LinkedList集合中了。在這裏一樣分析添加的方法（add(E e)），其餘方法先不看。

2.添加元素方法

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);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}
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;
    }
}

當使用LinkedList集合添加元素的時候，本質上並非直接添加這個元素到集合中，而是對這個元素進行了一次封裝，將其封裝成Node節點，再將Node添加到集合。這樣看來，LinkedList集合是將每個元素都當作了Node，添加元素的過程也是添加Node過程。

前面說過，LinkedList是雙向鏈表，他的每一個節點都保存着Node<E> prev和Node<E> next（即每一個節點都保存着指向前一個和後一個Node<E>的地址引用），這使得咱們能夠從第一個Node<E>的節點，一直查找next的節點，這樣就能對整個隊列進行正序遍歷（一樣能夠從最後的一個節點，一直查找prev的節點，就能夠從後到前進行倒序遍歷）。

上邊的添加元素的方法，首先將這個元素e封裝成Node<E> newNode ，由於是將元素添加到鏈表的尾部，因此這個new Node的第三個參數傳入null；其次將last賦值給l變量，這個last（全局變量）指的是鏈表的最後一個節點，由於要在尾部添加新的節點，因此last指向newNode節點（這裏有個if else 判斷，這個狀況是size是0的時候，LinkedList添加第一個元素，first和last都指向newNode）；最後是維護鏈表的大小(size)。

3.刪除方法

刪除方法remove(int)：

public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}
private void checkElementIndex(int index) {
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isElementIndex(int index) {
    return index >= 0 && index < size;
}
Node<E> node(int 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;
    }
}
E unlink(Node<E> x) {
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev
    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }
    x.item = null;
    size--;
    modCount++;
    return element;
}

在刪除元素的時候，會首先檢查index的大小是否正好在LinkedList的size內（不然會拋出IndexOutOfBoundsException異常）；其次linkedList會先找出元素所在的那個節點；最後將這個節點進行刪除。

node(int)方法按index查找節點；會先根據index與linkedList size的一半比較大小，若是小於，就從頭開始查找；大於就從尾部開始查找（與以前的方法相比，jdk8作了優化）。

刪除方法(unlink)。鏈表中的刪除，能夠理解爲解除關聯。好比一、二、3；三個元素，刪除2這個元素，只須要將1元素的next節點指向3，將3元素的prev指向1，再把2所在的節點的元素置空便可。unlink方法大意如此。

從上面分析add(e)和remove(index)方法，也能夠看出添加刪除的效率要比ArrayList高，由於LinkedList不須要維護角標，元素的位置不須要移動。
addAll和removeAll再也不贅述分析，這兩個方法和咱們分析上面的原理一致。

附錄：

ArrayList與LinkedList效率差異

@Test
public void testLV(){
    long a = System.currentTimeMillis();
    LinkedList<String> linkedList = new LinkedList<>();
    linkedList.add("1");
    linkedList.add("2");
    for (int i =0;i< 1000000;i++){
        linkedList.add(1,"A "+i);
    }
    long b = System.currentTimeMillis();
    System.out.println(b -a);

    long c = System.currentTimeMillis();
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("1");
    arrayList.add("2");
    for (int i =0;i< 1000000;i++){
        arrayList.add(1,"A "+i);
    }
    long d = System.currentTimeMillis();
    System.out.println(d - c);
}

每次插入都從1的位置插入。

結果：

第一次
LinkedList使用時間:  193
ArrayList使用時間:  127495
第二次
LinkedList使用時間:  179
ArrayList使用時間:  128867
第三次
LinkedList使用時間:  184
ArrayList使用時間:  130904

插入的數據越多，ArrayList維護的角標也越多，因此效率低。