Java類集框架 —— LinkedList源碼分析

時間  2019-11-30
標籤 java 框架 linkedlist 源碼 分析 欄目 Java 简体版
原文   原文鏈接

在JDK1.7以前，LinkedList是採用雙向環形鏈表來實現的，在1.7及以後，Oracle將LinkedList作了優化，將環形鏈表改爲了線性鏈表。本文對於LinkedList的源碼分析基於JDK1.8。node

LinkedList既然是經過一個雙向線性鏈表來實現，那麼確定就可以很輕易的找到鏈表的第一個節點和最後一個節點，在源碼中能夠看到有這兩個字段：數組

transient Node<E> first; // 鏈表第一個節點
transient Node<E> last;  // 鏈表最後一個節點複製代碼

先來看一下什麼是節點Node：bash

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 ： 上一個節點

節點中保存有須要存儲的元素，同時持有上一個節點和下一個節點的引用，各個節點依次持有先後節點的引用就造成了一個鏈，這樣，當咱們須要查找鏈中某一個節點保存的元素時，只須要經過第一個節點或者最後一個節點依次查找，就能夠找到咱們須要的節點。源碼分析

須要注意的是，在JDK1.7及以後，第一個節點first的前一個節點prev爲null，最後一個節點last的後一個節點next也爲null。而在JDK1.6及以前，頭節點header是一個不保存元素的節點，header的下一個節點next是第一個元素節點，而header的上一個節點是最後一個元素節點，這樣使得它造成一個環形的雙向鏈表。優化

LinkedList節點結構圖1（JDK1.7及之後）
LinkedList節點結構圖1（JDK1.7及之後）

LinkedList節點結構圖2（JDK1.6及之前）
LinkedList節點結構圖2（JDK1.6及之前）

LinkedList的構造函數有兩個，一個無參，另外一個能夠傳入一個集合：ui

public LinkedList() {
}

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

看下addAll方法的實現：this

public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}

public boolean addAll(int index, Collection<? extends E> c) {
    // 檢查是否越界
    checkPositionIndex(index);
    // 將集合c轉化爲數組a
    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;
    // pred爲插入元素位置點前一個節點，succ爲插入元素位置的後一個節點
    Node<E> pred, succ;     
    if (index == size) {    // index==size的話，在鏈表的末尾添加元素
        succ = null;
        pred = last;
    } else {                // 不然的話，從鏈表中間加入
        succ = node(index);
        pred = succ.prev;
    }
    // 遍歷須要加入的元素數組a
    for (Object o : a) {   
        // 經過元素o構造一個節點Node
        @SuppressWarnings("unchecked") E e = (E) o;
        Node<E> newNode = new Node<>(pred, e, null);
        if (pred == null) // 插入位置的前一個節點爲null，說明須要插入的是first節點
            first = newNode;
        else            // 插入位置的前一個節點不爲null，即從鏈表中或鏈表末尾插入
            // 將要插入的節點複製給插入位置的上一個節點的next
            pred.next = newNode;
        // 將newNode賦值給下個須要插入的節點的pred
        pred = newNode;
    }

    if (succ == null) { // succ爲null，說明是從末尾添加的元素，將添加的最後一個元素賦值給last
        last = pred;
    } else {            // 從鏈表中某個位置添加的，從新鏈接上添加元素時斷開的引用鏈
        pred.next = succ;
        succ.prev = pred;
    }
    // 更新鏈表的大小
    size += numNew;
    modCount++;
    return true;
}複製代碼

在構造方法中調用addAll方法，至關因而向一個空鏈表中添加集合c中的元素。spa

若是是在已有元素的鏈表中調用addAll方法來添加元素的話，就須要判斷指定的添加位置index是否越界，若是越界會拋出異常；若是沒有越界，根據添加的位置index，斷開鏈表中index位置的節點先後的引用，加入新元素，從新連上斷開位置的先後節點的引用。過程以下圖：code

LinkedList加入元素1
LinkedList加入元素1

LinkedList加入元素2
LinkedList加入元素2

add方法:

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

直接就調用了linkLast方法，說明默認的add方法是直接將元素添加到已有的鏈表的末尾。

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

新加入元素的節點賦值給last節點，而後判斷了一下加入以前的last節點是否爲空，爲空的話，說明鏈表中沒有元素，新加入的就是鏈表的first節點；不爲空直接將以前的最後一個節點的next引用添加的節點便可。

還有一個add方法，指定了添加位置：

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

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

先判斷是否越界，在判斷添加的位置是否在已有鏈表的末尾，若是在末尾就直接添加到末尾，不在末尾的話，調用linkBefore添加到index位置的節點以前。

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

pred爲null的話，說明succ是添加元素前鏈表的first節點，加入元素e，更新first節點，並更改引用鏈。

addFirst和addLast方法中分別調用了linkFirst方法和linkLast方法：

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

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

linkFirst/linkLast方法便是將新節點添加到鏈表的頭部或者尾部，更新鏈表的prev和next引用。

remove方法：

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

無論須要移除的元素O是否爲空，都是遍歷後調用unlink方法來刪除節點，繼續看unlink方法：

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) {
        // 若是prev爲null的話，那麼刪除的是first節點，將next指定爲刪除後的first節點
        first = next;
    } else {
        // prev不爲null，將prev的next引用指向next，並解除x元素對prev的引用
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        // 若是next爲null，那麼刪除的是last節點，將prev指定爲刪除後的last節點
        last = prev;
    } else {
        // next不爲null，將next的prev引用指向prev，並解除x的next引用
        next.prev = prev;
        x.next = null;
    }
    // 置空x節點中的元素
    x.item = null;
    size--;
    modCount++;
    return element;
}複製代碼

removeFirst和removeLast方法一樣是直接調用了unlinkFirst和unlinkLast，實現和unlink差很少，不作過多解釋。

set方法，set方法即修改鏈表中指定位置的元素：

public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}複製代碼

找到指定位置的節點x，更改該節點的item屬性就好了。

獲取節點的node方法：

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

判斷位置index是靠近頭部仍是尾部，靠近頭部，則從first節點日後遍歷，靠近尾部則從last節點往前遍歷，這種方式可使得鏈表查找的時候遍歷次數不會超過鏈表長度的一半，從而提高查找效率。

get、getFirst、getLast方法：

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

public E getFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}

public E getLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}複製代碼

getFirst和getLast直接後去first和last節點中的元素值，get方法則直接調用了node方法，再也不解釋。

LinkedList源碼中的其餘方法再也不分析了，實現都很容易理解。從LinkedList的增、刪、改、查等方法的實現邏輯能夠看出來，LinkedList的增和刪效率相對於改和查要高，由於每次修改和查詢都要從鏈表的頭節點或尾節點開始遍歷，而增長和刪除，只須要在制定位置斷開節點引用，添加和刪除元素後，從新連上引用鏈便可。因此，LinkedList適合用在添加和刪除比較頻繁，而修改和查詢較少的狀況下。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程