源碼分析——LinkedList

時間 2019-11-08

標籤源碼分析 linkedlist 欄目 Java 简体版

原文原文鏈接

前言

上一篇咱們分析了ArrayList這個用數組實現的List集合類，今天繼續來分析一個跟它比較類似的List集合類——LinkedList，不過LinkedList的底層實現是鏈表，它們內部的實現仍是有很大差別的。java

1. 概覽

類間關係圖：

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

能夠看到對比起 ArrayList，LinkedList並無實現RandomAccess 接口，因此咱們能夠知道它並不支持隨機訪問。接下來咱們看看LinkedList的具體實現node

每一個鏈表存儲了 first 和 last 指針分別指向頭節點和尾節點：
數組

//總節點數
transient int size = 0;
 //頭節點
transient Node<E> first;
//尾節點
transient Node<E> last;
複製代碼

能夠發現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;
    }
}複製代碼

下面是LinkedList的結構圖：數據結構

2. 添加

添加新元素多線程

public void add(E e) {
    checkForComodification();
    lastReturned = null;
    if (next == null)
        linkLast(e);
    else
        linkBefore(e, next);
    nextIndex++;
    expectedModCount++;
}複製代碼

添加到尾部或者插入到指定位置

//尾插到尾節點並將新節點設爲尾節點
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++;
}

//將新節點插入到指定節點前面
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++;
}
複製代碼

3. 修改

public E set(int index, E element) {
    // 檢查index是否合法
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}複製代碼

4. 刪除

public boolean remove(Object o) {
    if (o == 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;
}複製代碼

5. fail-fast機制

值得關注的是LinkedList在使用迭代器時也有 fail-fast 機制，在迭代的同時對LinkedList進行告終構上的操做就會觸發，拋出ConcurrentModificationException異常。具體源碼以下：

public void add(E e) {
    checkForComodification();
    lastReturned = null;
    if (next == null)
        linkLast(e);
    else
        linkBefore(e, next);
    nextIndex++;
    expectedModCount++;
}

public void set(E e) {
    if (lastReturned == null)
        throw new IllegalStateException();
    checkForComodification();
    lastReturned.item = e;
}

public void remove() {
    checkForComodification();
    if (lastReturned == null)
        throw new IllegalStateException();

    Node<E> lastNext = lastReturned.next;
    unlink(lastReturned);
    if (next == lastReturned)
        next = lastNext;
    else
        nextIndex--;
    lastReturned = null;
    expectedModCount++;
}

// fail-fast機制
final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}複製代碼