Java 集合系列三、骨骼驚奇之LinkedList

時間  2019-12-10
標籤 java 集合 系列 骨骼 驚奇 linkedlist 欄目 Java 简体版
原文   原文鏈接

一、LinkedList 概述

咱們在前面的文章中已經介紹過 List 你們族中的 ArrayList 和Vector 這兩位猶如孿生兄弟通常，從底層實現，功能都有着類似之處，除了一些我的行爲不一樣（成員變量，構造函數和方法線程安全）。接下來，咱們將會認識一下他們的另外一位功能強大的兄弟：LinkedListjava

LinkedList 的依賴關係：node

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
複製代碼
  • 一、繼承於 AbstractSequentialList ，本質上面與繼承 AbstractList 沒有什麼區別，AbstractSequentialList 完善了 AbstractList 中沒有實現的方法。
  • 二、Serializable：成員變量 Node 使用 transient 修飾，經過重寫read/writeObject 方法實現序列化。
  • 三、Cloneable：重寫clone（）方法，經過建立新的LinkedList 對象，遍歷拷貝數據進行對象拷貝。
  • 四、Deque：實現了Collection 你們庭中的隊列接口，說明他擁有做爲雙端隊列的功能。

eng～從上述實現接口來看，LinkedList 與 ArrayList 之間在總體上面的區別在於，LinkedList 實現了 Collection 你們庭中的Queue（Deque）接口，擁有做爲雙端隊列的功能。（就比如一個小孩子，他不只僅有父母的特性，他們有些人還會有舅舅的一些特性，比如 外甥長得像舅舅通常）。面試

二、LinkedList 成員變量

transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;
    
    
    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 的成員變量主要由 size（數據量大小），first(頭節點)和last（尾節點）。結合數據結構中雙端鏈表的思想，每一個節點須要擁有，保存數據（E item），指向下一節點（Node next ）和指向上一節點（Node prev）。數組

LinkedList 與ArrayLit、Vector 的成員變量對比中，明顯沒有提供 MAX_ARRAY_SIZE 這一個最大值的限定，這是因爲鏈表沒有長度限制的緣由，他的內存地址不須要分配固定長度進行存儲，只須要記錄下一個節點的存儲地址便可完成整個鏈表的連續。安全

拓展思考： LinkedList 中 JDK 1.8 與JDK 1.6 有哪些不一樣？bash

主要不一樣爲，LinkedList 在1.6 版本以及以前，只經過一個 header 頭指針保存隊列頭和尾。這種操做能夠說頗有深度，可是從代碼閱讀性來講，卻加深了閱讀代碼的難度。所以在後續的JDK 更新中，將頭節點和尾節點 區分開了。節點類也改名爲 Node。數據結構

三、LinkedList 構造函數

LinkedList 只提供了兩個構造函數：dom

  • LinkedList()
  • LinkedList(Collection<? extends E> c)

在JDK1.8 中，LinkedList 的構造函數 LinkedList（） 是一個空方法，並無提供什麼特殊操做。區別於 JDK1.6 中，會初始化 header 爲一個空的指針對象。函數

3.1 LinkedList()

JDK 1.6post

private transient Entry<E> header = new Entry<E>(null, null, null);
    public LinkedList() {
        header.next = header.previous = header;
    }

複製代碼

JDK 1.8 在使用的時候，纔會建立第一個節點。

public LinkedList() {
    }
複製代碼

3.2 LinkedList(Collection<? extends E> c)

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

這一構造方法主要經過 調用addAll 進行建立對象，在介紹LinkedList 添加方法的時候再進行細述。

3.3 小結

LinkedList 在新版本的實現中，除了區分了頭節點和尾節點外，更加註重在使用時進行內存分配，這裏跟ArrayList 相似（ArrayList 默認構造器是建立一個空的數組對象）。

四、添加方法（Add）

LinkedList 繼承了 AbstractSequentialList（AbstractList），同時實現了Deque 接口，所以，他在添加方法 這一塊，包含了二者的操做：

AbstractSequentialList:

  • add(E e)
  • add(int index，E e)
  • addAll(Collection<? extends E> c)
  • addAll(int index, Collection<? extends E> c)

Deque

  • addFirst(E e)
  • addLast(E e)
  • offer(E e)
  • offerFirst(E e)
  • offerLast(E e)

4.1 add(E e) & addLast(E e) & offer(E e) & offerLast(E e)

雖然 LinkedList 分別實現了List 和 Deque 的添加方法，可是在某種意義上，這些方法其實都是有共性的。例如，咱們調用add（E e） 方法，不論是ArrayList 或 Vector 等列表，都是默認在數組末尾進行添加，所以與 隊列中在末尾添加節點 addLast（E e） 是有着同樣的韻味的。因此，從LinkedList 的源碼中，這幾個方法，底層操做實際上是一致的。

public boolean add(E e) {
        linkLast(e);
        return true;
    }
    
    public void addLast(E e) {
        linkLast(e);
    }
    
     public boolean offer(E e) {
        return add(e);
    }
    
    public boolean offerLast(E e) {
        addLast(e);
        return true;
    }
    
    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++;
    }
複製代碼

咱們主要分析一下 linkLast 這個方法：

  • 獲取尾節點（last）
  • 建立插入節點，而且設置上一節點爲 last，下一節點爲 null。
  • 設置新節點爲末尾節點（last）
  • 若是 l（初始末尾節點）==null，說明這是第一次操做，新加入的爲頭節點
  • 不然，設置 l（初始末尾節點）的下一節點爲新加入的節點
  • size + 1，操做計數 + 1

拓展思考：爲何內部變量 Node l 須要使用 final 進行修飾？

4.2 addFirst(E e) & offerFirst（E e）

public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }
    
    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++;
        modCount++;
    }
複製代碼

從上述代碼能夠看出，offerFirst 和addFirst 其實都是同樣的操做，只是返回的數據類型不一樣。而 linkFirst 方法，則與 linkLast 實際上是同樣的思想，這裏也不作細述。

4.3 add(int index，E e)

這裏咱們主要講一下，爲何LinkedList 在添加、刪除元素這一方面優於 ArrayList。

public void add(int index, E element) {
        checkPositionIndex(index);
        // 若是插入節點爲末尾，直接插入
        if (index == size)
            linkLast(element);
        // 不然，找到該節點，進行插入
        else
            linkBefore(element, node(index));
    }
    
    Node<E> node(int index) {
        // 這裏順序查找元素，經過二分查找的方式，決定從頭或尾節點開始進行查找，時間複雜度爲 n/2
        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;
        }
    }
    
    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++;
    }
複製代碼

LinkedList 在 add（int index，Element e）方法的流程

  • 判斷下標有效性
  • 若是插入位置爲末尾，直接插入
  • 不然，遍歷1/2的鏈表找到 index 下標的節點
  • 經過 succ 設置新節點的前，後節點

LinkedList 在插入數據之因此會優於ArrayList，主要是因爲在插入數據這一環節（linkBefore），插入計算只須要設置節點的前，後節點便可，而ArrayList 則須要將整個數組的數據進行後移（

System.arraycopy(elementData, index, elementData, index + 1,size - index);
複製代碼

）

4.4 addAll(Collection<? extends E> c)

LinkedList 中提供的兩個addAll 方法中，其實內部實現也是同樣的，主要經過： addAll(int index, Collection<? extends E> c)進行實現：

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;

        Node<E> pred, succ;
        //獲取插入節點的前節點（prev）和尾節點（next）
        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;
        }
        //將 Collection 的鏈表插入 LinkedList 中。
        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;
        modCount++;
        return true;
    }
    
複製代碼

4.5 小結

LinkedList 在插入數據優於ArrayList ，主要是由於他只須要修改指針的指向便可，而不須要將整個數組的數據進行轉移。而LinkedList 優於沒有實現 RandomAccess，或者說 不支持索引搜索的緣由，他在查找元素這一操做，須要消耗比較多的時間進行操做（n/2）。

五、刪除方法（Remove）

AbstractSequentialList：

  • remove（int index）
  • remove（Object o）

Deque

  • remove()
  • removeFirst()
  • removeLast()
  • removeFirstOccurrence(Object o)
  • removeLastOccurrence(Object o)

5.1 remove（int index)&remove（Object o）

在 ArrayList 中，remove（Object o） 方法，是經過遍歷數組，找到下標後，經過fastRemove（與 remove（int i） 相似的操做）進行刪除。而LinkedList，則是遍歷鏈表，找到目標節點（node），經過 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) {
            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;
    }
複製代碼

整個過程爲：

  • 獲取目標節點的 next、prev
  • 若是prev 爲空，說明目標節點爲頭節點
  • 設置first 爲目標節點的下一節點（next）
  • 不然設置prev節點的下一節點爲next（即將本身重鏈表中剔除）
  • 若是 next 爲空，說明目標節點爲尾節點
  • 設置last 爲目標節點的上一節點
  • 不然，設置next節點的上一節點爲prev
  • 將目標節點設置爲null

能夠看到，刪除方法與添加方法相似，只須要修改節點關係便可，避免了相似於ArrayList 的數組平移狀況，大大減小了時間損耗。

5.2 Deque 中的Remove

Deque 中的 removeFirstOccurrence 和 removeLastOccurrence 主要過程爲，首先從first/last 節點開始遍歷，當發現第一個目標對象，則低哦啊用remove（Object o） 進行刪除對象。整體上沒有什麼特別之處。

稍有不一樣的是Deque 中的removeFirst（）和removeLast（）方法，在底層實現上面，因爲明確知道刪除的對象爲first/last對象，所以在刪除操做上面 會更加簡單：

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

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

總體操做爲，將first 節點的next 設置爲新的頭節點，而後將 f 清空。 removeLast 操做也相似。

結合隊列的思想，removeFirst 和removeLast 都會返回 數據 E，至關於咱們的出列操做（pollFirst/pollLast）

6 LinkedList 雙端鏈表

咱們之因此說LinkedList 爲雙端鏈表，是由於他實現了Deque 接口，支持隊列的一些操做，咱們來看一下有哪些方法實現：

  • pop（）
  • poll（）
  • push（）
  • peek（）
  • offer（）

能夠看到Deque 中提供的方法主要有上述的幾個方法，接下來咱們來看看在LinkedList 中是如何實現這些方法的。

6.1 pop（） & poll（）

LinkedList#pop 的源碼：

public E pop() {
       return removeFirst();
   }
       public E removeFirst() {
       final Node<E> f = first;
       if (f == null)
           throw new NoSuchElementException();
       return unlinkFirst(f);
   }
複製代碼

從上述代碼能夠看出，Pop（） 的操做爲，隊列頭部元素出隊列，若是過first 爲空 會拋出異常。

LinkedList#poll 的源碼：

public E poll() {
       final Node<E> f = first;
       return (f == null) ? null : unlinkFirst(f);
   }
複製代碼

對比 pop 和poll 的源碼能夠看到，雖然一樣是 first 出列，不一樣的是，若是first 爲null， pop（）方法會拋出異常。

6.2 push（）

push（） 方法的底層實現，其實就是調用了 addFirst（Object o）：

public void push(E e) {
       addFirst(e);
   }
複製代碼

push()方法的操做，主要跟 棧（Stack） 中的入棧操做相似。

6.3 peek（）

LinkedList#peek 操做主要爲，將取隊列頭部元素的值（根據隊列的 FIFO，peek爲取頭部數據）

public E peek() {
       final Node<E> f = first;
       return (f == null) ? null : f.item;
   }
   
複製代碼

6.3 offer（）

offer()方法爲直接調用添加方法。

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

7 LinkedList 遍歷

LinkedList 因爲沒有實現 RandomAccess，所以，在以隨機訪問的形式進行遍歷時效果會很是低下。除此以外，LinkedList 提供了相似於經過Iterator 進行遍歷，節點的prev 或 next 進行遍歷，還有for循環遍歷，都有不錯的效果。

8 總結

沒有太多的拓展思考，腦子不夠清晰，整體來講，List 接口下面的小家庭的源碼以及分析完了。對每個成員都有了進一步的瞭解，面試的時候，也不會再簡單的回答，linkedList 插入刪除性能比較好，ArrayList 能過快速定位元素，Vector 是線程安全。只有在充分了解其實現，你纔會發現，你回答的雖然沒錯，可是也就60分而已，若是你想要將每個問題回答的完美，那麼請認真思考，認真去了解它。

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