Java集合詳解（三）：LinkedList原理解析

概述

　　本文是基於jdk8_271源碼進行分析的。

　　LinkedList底層是基於鏈表實現。鏈表沒有長度限制，內存地址不需要固定長度，也不需要是連續的地址來進行存儲，只需要通過引用來關聯前后元素即可完成整個鏈表的連續。所以鏈表的優點就是添加刪除元素比較快，只需要移動指針，並且不需要判斷擴容。缺點就是因為沒有索引，所以在查詢和遍歷元素時候比較慢。

　　使用場景：在增刪操作使用較多，查詢遍歷操作使用較少情況下比較適合去使用；例如：拿來當棧使用。

數據結構

• 繼承實現關系

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

1. AbstractSequentialList ：本質上面與繼承 AbstractList 沒有什么區別，AbstractSequentialList 完善了 AbstractList 中沒有實現的方法。
2. List：實現List接口。
3. Deque：實現Deque隊列接口，擁有作為雙端隊列（隊列和棧）的功能。
   
4. Cloneable：重寫clone()方法，通過創建新的LinkedList 對象，遍歷拷貝數據進行對象拷貝。
5. Serializable：重寫read/writeObject() 方法實現序列化。

• 靜態內部類

　　為什么Node這個類是靜態的？答案是：這跟內存泄露有關，Node類是在LinkedList類中的，也就是一個內部類，若不使用static修飾，那么Node就是一個普通的內部類，在java中，一個普通內部類在實例化之后，默認會持有外部類的引用，這就有可能造成內存泄露（內部類與外部類生命周期不一致時）。但使用static修飾過的內部類（稱為靜態內部類），就不會有這種問題。

　　非靜態內部類會自動生成一個構造器依賴於外部類：也是內部類可以訪問外部類的實例變量的原因。

　　靜態內部類不會生成，訪問不了外部類的實例變量，只能訪問類變量。

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

• 基本屬性

    // 元素數量
    transient int size = 0;
    // 頭結點
    transient Node<E> first;
    // 尾節點
    transient Node<E> last;

• 構造方法

    public LinkedList() {
    }

    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

主要方法解析

•  獲取元素

　　peek()：隊列的查，獲取隊頭元素。

    public E get(int index) {    // 根據索引獲取
        checkElementIndex(index);
        return node(index).item;
    }
    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;
        }
    }
    // 獲取隊頭元素 ，但是不刪除隊列的頭元素（雙端隊列Deque中的方法）
    public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }
    // 獲取隊尾元素，但是不刪除隊列的尾元素（實現雙端隊列Deque中的方法）
    public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

    // 隊列的查。獲取隊頭元素。
    public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }

• 添加元素

　　offer()：隊列的增，添加隊尾元素，底層實現是調用add()->linkLast()。

　　push()：棧的增，把元素壓入棧中，添加對頭元素，底層實現是調用addFirst()->linkFirst()。

    // 添加元素，默認在鏈表尾部添加
    public boolean add(E e) {
        linkLast(e);
        return true;
    }
    // 指定索引添加元素
    public void add(int index, E element) {
        checkPositionIndex(index);  // 檢驗下標是否越界

        if (index == size)  // 如果要插入的索引等於現有元素長度，說明是要在尾部插入元素
            linkLast(element);
        else    // 否則，獲取該索引節點，在該節點之前插入元素
            linkBefore(element, node(index));
    }

    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;

        // pred:前置節點，在該節點之后插入元素。succ：該索引位節點。
        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;
    }

    // 添加元素到頭結點（實現雙端隊列Deque中的方法）
    public void addFirst(E e) {
        linkFirst(e);
    }
    private void linkFirst(E e) {
        final Node<E> f = first;    // 原頭節點
        final Node<E> newNode = new Node<>(null, e, f); // 新建一個節點，要添加的元素
        first = newNode;    // 將頭結點指向該新建的節點
        if (f == null)  // 如果原頭結點為空，說明原鏈表為空。這是添加的第一個元素，將尾結點也指向該新建的節點
            last = newNode;
        else    // 如果原頭結點不為空，則將原頭結點的前置節點指向該新建的節點
            f.prev = newNode;
        size++; // 元素數量+1
        modCount++; // 修改次數+1
    }
    // 添加元素到尾結點（實現雙端隊列Deque中的方法）
    public void addLast(E e) {
        linkLast(e);
    }
    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++; // 元素數量+1
        modCount++; // 修改次數+1
    }

    // 隊列的添加方法
    public boolean offer(E e) {
        return add(e);
    }

    // 棧的添加方法
    public void push(E e) {
        addFirst(e);
    }

• 刪除元素

　　poll()：隊列的刪，獲取對頭元素並且對頭元素刪除。

　　pop()：棧的刪，返回的是棧頂元素並將棧頂元素刪除。

    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;
    }
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }
    // 將該節點前置節點的下一個節點指向該節點后繼節點，將該節點后繼節點的上一個節點指向該節點前置節點。並將該節點置為空
    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) {
            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;
    }
    // 將頭結點的下一個節點設置為新的頭結點，並將原頭節點置為空
    private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        final E element = f.item;
        final Node<E> next = f.next;
        f.item = null;
        f.next = null; // help GC
        first = next;
        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

    // 將尾結點的上一個節點設置為新的尾結點，並將原尾節點置為空
    private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;
        final E element = l.item;
        final Node<E> prev = l.prev;
        l.item = null;
        l.prev = null; // help GC
        last = prev;
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

    public E remove() {
        return removeFirst();
    }

    // 隊列的刪除方法
    public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
    // 棧的刪除方法
    public E pop() {
        return removeFirst();
    }

附錄

LinkedList源碼詳細注釋Github地址：https://github.com/y2ex/jdk-source/blob/jdk1.8.0_271/src/main/java/java/util/LinkedList.java

jdk1.8源碼Github地址：https://github.com/y2ex/jdk-source/tree/jdk1.8.0_271