計算機程序的思惟邏輯 (39) - 剖析LinkedList

時間 2019-11-29

原文原文鏈接

本系列文章經補充和完善，已修訂整理成書《Java編程的邏輯》（馬俊昌著），由機械工業出版社華章分社出版，於2018年1月上市熱銷，讀者好評如潮！各大網店和書店有售，歡迎購買：京東自營連接 html

上節咱們介紹了ArrayList，ArrayList隨機訪問效率很高，但插入和刪除性能比較低，咱們提到了一樣實現了List接口的LinkedList，它的特色與ArrayList幾乎正好相反，本節咱們就來詳細介紹LinkedList。java

除了實現了List接口外，LinkedList還實現了Deque和Queue接口，能夠按照隊列、棧和雙端隊列的方式進行操做，本節會介紹這些用法，同時介紹其實現原理。node

咱們先來看它的用法。編程

用法

構造方法

LinkedList的構造方法與ArrayList相似，有兩個，一個是默認構造方法，另一個能夠接受一個已有的Collection，以下所示：數組

public LinkedList() public LinkedList(Collection<? extends E> c) 複製代碼

好比，能夠這麼建立：微信

List<String> list = new LinkedList<>();
List<String> list2 = new LinkedList<>(
        Arrays.asList(new String[]{"a","b","c"}));
複製代碼

List接口

LinkedList與ArrayList同樣，一樣實現了List接口，而List接口擴展了Collection接口，Collection又擴展了Iterable接口，全部這些接口的方法都是可使用的，使用方法與上節介紹的同樣，本節就再也不贅述了。數據結構

隊列 (Queue)

LinkedList還實現了隊列接口Queue，所謂隊列就相似於平常生活中的各類排隊，特色就是先進先出，在尾部添加元素，從頭部刪除元素，它的接口定義爲：函數

public interface Queue<E> extends Collection<E> {
    boolean add(E e);
    boolean offer(E e);
    E remove();
    E poll();
    E element();
    E peek();
} 
複製代碼

Queue擴展了Collection，它的主要操做有三個：性能

在尾部添加元素 (add, offer)
查看頭部元素 (element, peek)，返回頭部元素，但不改變隊列
刪除頭部元素 (remove, poll)，返回頭部元素，而且從隊列中刪除

每種操做都有兩種形式，有什麼區別呢？區別在於，對於特殊狀況的處理不一樣。特殊狀況是指，隊列爲空或者隊列爲滿，爲空容易理解，爲盡是指隊列有長度大小限制，並且已經佔滿了。LinkedList的實現中，隊列長度沒有限制，但別的Queue的實現可能有。this

在隊列爲空時，element和remove會拋出異常NoSuchElementException，而peek和poll返回特殊值null，在隊列爲滿時，add會拋出異常IllegalStateException，而offer只是返回false。

把LinkedList當作Queue使用也很簡單，好比，能夠這樣：

Queue<String> queue = new LinkedList<>();

queue.offer("a");
queue.offer("b");
queue.offer("c");

while(queue.peek()!=null){
    System.out.println(queue.poll());    
}
複製代碼

輸出爲：

a
b
c
複製代碼

棧

咱們在介紹函數調用原理的時候介紹過棧，棧也是一種經常使用的數據結構，與隊列相反，它的特色是先進後出、後進先出，相似於一個儲物箱，放的時候是一件件往上放，拿的時候則只能從上面開始拿。

Java中有一個類Stack，用於表示棧，但這個類已通過時了，咱們再也不介紹，Java中沒有單獨的棧接口，棧相關方法包括在了表示雙端隊列的接口Deque中，主要有三個方法：

void push(E e);
E pop();
E peek();
複製代碼

解釋下：

push表示入棧，在頭部添加元素，棧的空間多是有限的，若是棧滿了，push會拋出異常IllegalStateException。
pop表示出棧，返回頭部元素，而且從棧中刪除，若是棧爲空，會拋出異常NoSuchElementException。
peek查看棧頭部元素，不修改棧，若是棧爲空，返回null。

把LinkedList當作棧使用也很簡單，好比，能夠這樣：

Deque<String> stack = new LinkedList<>();

stack.push("a");
stack.push("b");
stack.push("c");

while(stack.peek()!=null){
    System.out.println(stack.pop());    
}
複製代碼

輸出爲：

c
b
a
複製代碼

雙端隊列 (Deque)

棧和隊列都是在兩端進行操做，棧只操做頭部，隊列兩端都操做，但尾部只添加、頭部只查看和刪除，有一個更爲通用的操做兩端的接口Deque，Deque擴展了Queue，包括了棧的操做方法，此外，它還有以下更爲明確的操做兩端的方法：

void addFirst(E e);
void addLast(E e);
E getFirst();
E getLast();
boolean offerFirst(E e);
boolean offerLast(E e);
E peekFirst();
E peekLast();
E pollFirst();
E pollLast();
E removeFirst();
E removeLast();
複製代碼

xxxFirst操做頭部，xxxLast操做尾部。與隊列相似，每種操做有兩種形式，區別也是在隊列爲空或滿時，處理不一樣。爲空時，getXXX/removeXXX會拋出異常，而peekXXX/pollXXX會返回null。隊列滿時，addXXX會拋出異常，offerXXX只是返回false。

棧和隊列只是雙端隊列的特殊狀況，它們的方法均可以使用雙端隊列的方法替代，不過，使用不一樣的名稱和方法，概念上更爲清晰。

Deque接口還有一個迭代器方法，能夠從後往前遍歷

Iterator<E> descendingIterator();
複製代碼

好比，看以下代碼：

Deque<String> deque = new LinkedList<>(
        Arrays.asList(new String[]{"a","b","c"}));
Iterator<String> it = deque.descendingIterator();
while(it.hasNext()){
    System.out.print(it.next()+" ");
}
複製代碼

輸出爲

c b a 
複製代碼

用法小結

LinkedList的用法是比較簡單的，與ArrayList用法相似，支持List接口，只是，LinkedList增長了一個接口Deque，能夠把它看作隊列、棧、雙端隊列，方便的在兩端進行操做。

若是隻是用做List，那應該用ArrayList仍是LinkedList呢？咱們須要瞭解下LinkedList的實現原理。

實現原理

內部組成

咱們知道，ArrayList內部是數組，元素在內存是連續存放的，但LinkedList不是。LinkedList直譯就是鏈表，確切的說，它的內部實現是雙向鏈表，每一個元素在內存都是單獨存放的，元素之間經過連接連在一塊兒，相似於小朋友之間手拉手同樣。

爲了表示連接關係，須要一個節點的概念，節點包括實際的元素，但同時有兩個連接，分別指向前一個節點(前驅)和後一個節點(後繼)，節點是一個內部類，具體定義爲：

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類表示節點，item指向實際的元素，next指向下一個節點，prev指向前一個節點。

LinkedList內部組成就是以下三個實例變量：

transient int size = 0;
transient Node<E> first;
transient Node<E> last;
複製代碼

咱們暫時忽略transient關鍵字，size表示鏈表長度，默認爲0，first指向頭節點，last指向尾節點，初始值都爲null。

LinkedList的全部public方法內部操做的都是這三個實例變量，具體是怎麼操做的？連接關係是如何維護的？咱們看一些主要的方法，先來看add方法。

Add方法

add方法的代碼爲：

public boolean add(E e) {
    linkLast(e);
    return true;
}
複製代碼

主要就是調用了linkLast，它的代碼爲：

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++;
}
複製代碼

代碼的基本步驟是：

建立一個新的節點newNode。prev指向原來的尾節點，若是原來鏈表爲空，則爲null。代碼爲：

Node<E> newNode = new Node<>(l, e, null);
複製代碼

修改尾節點last，指向新的最後節點newNode。代碼爲：

last = newNode;
複製代碼

修改前節點的後向連接，若是原來鏈表爲空，則讓頭節點指向新節點，不然讓前一個節點的next指向新節點。代碼爲：

if (l == null)
    first = newNode;
else
    l.next = newNode;
複製代碼

增長鏈表大小。代碼爲：

size++
複製代碼

modCount++的目的與ArrayList是同樣的，記錄修改次數，便於迭代中間檢測結構性變化。

咱們經過一些圖示來更清楚的看一下，好比說，代碼爲：

List<String> list = new LinkedList<String>();
list.add("a");
list.add("b");
複製代碼

執行完第一行後，內部結構以下所示：

添加完"a"後，內部結構以下所示：

添加完"b"後，內部結構以下所示：

能夠看出，與ArrayList不一樣，LinkedList的內存是按需分配的，不須要預先分配多餘的內存，添加元素只需分配新元素的空間，而後調節幾個連接便可。

根據索引訪問元素 get

添加了元素，若是根據索引訪問元素呢？咱們看下get方法的代碼：

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}
複製代碼

checkElementIndex檢查索引位置的有效性，若是無效，拋出異常，代碼爲：

private void checkElementIndex(int index) {
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private boolean isElementIndex(int index) {
    return index >= 0 && index < size;
}
複製代碼

若是index有效，則調用node方法查找對應的節點，其item屬性就指向實際元素內容，node方法的代碼爲：

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;
    }
}
複製代碼

size>>1等於size/2，若是索引位置在前半部分 (index<(size>>1))，則從頭節點開始查找，不然，從尾節點開始查找。

能夠看出，與ArrayList明顯不一樣，ArrayList中數組元素連續存放，能夠直接隨機訪問，而在LinkedList中，則必須從頭或尾，順着連接查找，效率比較低。

根據內容查找元素

咱們看下indexOf的代碼：

public int indexOf(Object o) {
    int index = 0;
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    return -1;
}
複製代碼

代碼也很簡單，從頭節點順着連接日後找，若是要找的是null，則找第一個item爲null的節點，不然使用equals方法進行比較。

插入元素

add是在尾部添加元素，若是在頭部或中間插入元素呢？可使用以下方法：

public void add(int index, E element) 複製代碼

它的代碼是：

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

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}
複製代碼

若是index爲size，添加到最後面，通常狀況，是插入到index對應節點的前面，調用方法爲linkBefore，它的代碼爲：

void linkBefore(E e, Node<E> succ) {
    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++;
}
複製代碼

參數succ表示後繼節點。變量pred就表示前驅節點。目標就是在pred和succ中間插入一個節點。插入步驟是：

新建一個節點newNode，前驅爲pred，後繼爲succ。代碼爲：

Node<E> newNode = new Node<>(pred, e, succ);
複製代碼

讓後繼的前驅指向新節點。代碼爲：

succ.prev = newNode;
複製代碼

讓前驅的後繼指向新節點，若是前驅爲空，修改頭節點指向新節點。代碼爲：

if (pred == null)
    first = newNode;
else
    pred.next = newNode;
複製代碼

增長長度。

咱們經過圖示來更清楚的看下，仍是上面的例子，好比，添加一個元素：

list.add(1, "c");
複製代碼

圖示結構會變爲：

能夠看出，在中間插入元素，LinkedList只需按需分配內存，修改前驅和後繼節點的連接，而ArrayList則可能須要分配不少額外空間，且移動全部後續元素。

刪除元素

咱們再來看刪除元素，代碼爲：

public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}
複製代碼

經過node方法找到節點後，調用了unlink方法，代碼爲：

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;
}
複製代碼