JDK核心JAVA源碼解析（7）- 集合相關（1） - LinkedList

想寫這個系列好久了，對本身也是個總結與提升。原來在學JAVA時，那些JAVA入門書籍會告訴你一些規律還有法則，可是用的時候咱們通常很難想起來，由於咱們用的少而且不知道爲何。知其因此然方能印象深入並學以至用。

本篇文章針對JAVA中集合類LinkedList進行分析，經過代碼解釋Java中的Fail-fast設計思想，以及LinkedList底層實現和與ArrayList對比下的就業場景。

本文會經過QA的方式行文

本文基於JDK 11

1. LinkedList實際結構是什麼樣子的？是單向鏈表仍是雙向？

是雙向鏈表。LinkedList不光實現了List接口，還實現了Deque接口。

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

2. 爲什麼LinkedList更加耗費空間？

由於要實現雙向鏈表，雙向隊列的機制，同時能夠存儲null值（也就是有額外的引用變量指向實際的節點數據），每一個節點都是由三個引用組成：

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

這樣，存儲佔用了更多空間。

3. LinkedList有哪些基本操做，複雜度如何？

• 除了基本的add(E element)還有addAll(Collection<E> elements)之外，還有addFisrt(E element)和addLast(E element)可使用。因爲LinkedList而外維護了指向頭結點還有尾節點的指針，因此複雜度都是O(1)

/**
* Pointer to first node.
*/
//因爲這些不必序列化，因此加上transient
transient Node<E> first;

/**
* Pointer to last node.
*/
transient Node<E> last;

• get(int index)等全部涉及到下標操做的方法，因爲須要遍歷，複雜度都是O(N/2).實現遍歷的核心方法是：

Node<E> node(int index) {
   //看index是否大於size一半或者小於，決定從鏈表頭遍歷仍是末尾遍歷
   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;
   }
}

• 和add(E element)相似，remove(E element)也有對應的removeFirst()和removeLast()存在（對於空的鏈表會拋出NoSuchElementException），而且因爲LinkedList而外維護了指向頭結點還有尾節點的指針，因此複雜度都是O(1)。可是remove(Object o)的複雜度是O(N)，由於是從開頭遍歷尋找第一個equals返回true的。同時還有removeFirstOccurrence(Object o)（和remove等價）和removeLastOccurrence(Object o)方法。

public boolean removeLastOccurrence(Object o) {
   //對於null的值，直接尋找爲null的，不然經過調用equals判斷是否相等
   if (o == null) {
       for (Node<E> x = last; x != null; x = x.prev) {
           if (x.item == null) {
               unlink(x);
               return true;
           }
       }
   } else {
       for (Node<E> x = last; x != null; x = x.prev) {
           if (o.equals(x.item)) {
               unlink(x);
               return true;
           }
       }
   }
   return false;
}

• 基本隊列操做也有。poll()和pop()效果相同，都是將隊列第一個元素剔除並返回。不一樣的是，針對空鏈表，poll()返回null，pop()拋出NoSuchElementException異常（由於底層實現就是removeFirst()）

4. 什麼是fail-fast，集合類中是如何實現的？LinkedList如何實現的？

fail-fast指的是在可能的損害發生前，直接失敗。在JAVA中的一種體現就是當某個集合的Iterator已經建立後，若是修改了集合，再訪問Iterator進行遍歷就會拋出 ConcurrentModificationException

LinkedList和其它集合相似，經過modCount這個field實現。

全部修改都會讓modCount++。生成的Iterator會記錄這個modCount，若是modCount發生改變，拋出 ConcurrentModificationException：

private class ListItr implements ListIterator<E> {
    private Node<E> lastReturned;
    private Node<E> next;
    private int nextIndex;
    private int expectedModCount = modCount;

    ListItr(int index) {
        // assert isPositionIndex(index);
        next = (index == size) ? null : node(index);
        nextIndex = index;
    }
    //舉一個方法做爲例子，其餘省略...

    public void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (modCount == expectedModCount && nextIndex < size) {
            action.accept(next.item);
            lastReturned = next;
            next = next.next;
            nextIndex++;
        }
        checkForComodification();
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

還有一些其餘的擴展迭代器，例如Spliterator，也是fail-fast的

5. 若是須要對List排序，用ArrayList比較好仍是LinkedList？

集合排序基本上都是基於這個方法：Collections.swap()

public static void swap(List<?> list, int i, int j) {
    final List l = list;
    l.set(i, l.set(j, l.get(i)));
}

基本都是下標操做，因此，ArrayList更好

6. 爲什麼LinkedList非線程安全？

咱們來看在末尾加元素的方法：

void linkLast(E e) {
    //假設原始last爲1，新加入兩個節點2，3
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    //假設這裏發生了線程切換，將會發生，1->2->null以後變成1->3->null的狀況
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    //++都不是線程安全的，致使size誤判
    size++;
    modCount++;
}

若是想實現線程安全的list：

• 使用Vector（適用於更新比較多）或者CopyOnWriteArrayList（適用於讀取比較多）
• 經過:

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

獲取併發安全LinkedList

7. 爲何JDK默認的List實現是ArrayList而不是LinkedList？

在大部分場景（遍歷，下標查找，排序等）下，ArrayList性能更佳而且佔用存儲空間小。只有下標插入刪除這種場景，LinkedList更有優點。