JDK1.8源碼(六)——java.util.LinkedList 類

時間 2020-07-06

標籤 jdk1.8 jdk 源碼 java.util.linkedlist java util linkedlist 欄目 Java 简体版

原文原文鏈接

　　上一篇博客咱們介紹了List集合的一種典型實現 ArrayList，咱們知道 ArrayList 是由數組構成的，本篇博客咱們介紹 List 集合的另外一種典型實現 LinkedList。html

一、LinkedList 定義

　　LinkedList 是一個用鏈表實現的集合，元素有序且能夠重複。java

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

　　和 ArrayList 集合同樣，LinkedList 集合也實現了Cloneable接口和Serializable接口，分別用來支持克隆以及支持序列化。List 接口也不用多說，定義了一套 List 集合類型的方法規範。node

　　注意，相對於 ArrayList 集合，LinkedList 集合多實現了一個 Deque 接口，這是一個雙向隊列接口，雙向隊列就是兩端均可以進行增長和刪除操做。api

二、字段屬性

//鏈表元素（節點）的個數
    transient int size = 0;

    /**
     *指向第一個節點的指針
     */
    transient Node<E> first;

    /**
     *指向最後一個節點的指針
     */
    transient Node<E> last;

　　注意這裏出現了一個 Node 類，這是 LinkedList 類中的一個內部類，其中每個元素就表明一個 Node 類對象，LinkedList 集合就是由許多個 Node 對象相似於手拉着手構成。數組

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 是有四個元素，也就是由 4 個 Node 對象組成，size=4，head 指向第一個elementA,tail指向最後一個節點elementD。oracle

三、構造函數

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

　　LinkedList 有兩個構造函數，第一個是默認的空的構造函數，第二個是將已有元素的集合Collection 的實例添加到 LinkedList 中，調用的是 addAll() 方法，這個方法下面咱們會介紹。函數

　　注意：LinkedList 是沒有初始化鏈表大小的構造函數，由於鏈表不像數組，一個定義好的數組是必需要有肯定的大小，而後去分配內存空間，而鏈表不同，它沒有肯定的大小，經過指針的移動來指向下一個內存地址的分配。優化

四、添加元素

　　①、addFirst(E e)
　　將指定元素添加到鏈表頭ui

//將指定的元素附加到鏈表頭節點
    public void addFirst(E e) {
        linkFirst(e);
    }
    private void linkFirst(E e) {
        final Node<E> f = first;//將頭節點賦值給 f
        final Node<E> newNode = new Node<>(null, e, f);//將指定元素構形成一個新節點，此節點的指向下一個節點的引用爲頭節點
        first = newNode;//將新節點設爲頭節點，那麼原先的頭節點 f 變爲第二個節點
        if (f == null)//若是第二個節點爲空，也就是原先鏈表是空
            last = newNode;//將這個新節點也設爲尾節點（前面已經設爲頭節點了）
        else
            f.prev = newNode;//將原先的頭節點的上一個節點指向新節點
        size++;//節點數加1
        modCount++;//和ArrayList中同樣，iterator和listIterator方法返回的迭代器和列表迭代器實現使用。
    }

　　②、addLast(E e)和add(E e)
　　將指定元素添加到鏈表尾

//將元素添加到鏈表末尾
    public void addLast(E e) {
        linkLast(e);
    }
    //將元素添加到鏈表末尾
    public boolean add(E e) {
        linkLast(e);
        return true;
    }
    void linkLast(E e) {
        final Node<E> l = last;//將l設爲尾節點
        final Node<E> newNode = new Node<>(l, e, null);//構造一個新節點，節點上一個節點引用指向尾節點l
        last = newNode;//將尾節點設爲建立的新節點
        if (l == null)//若是尾節點爲空，表示原先鏈表爲空
            first = newNode;//將頭節點設爲新建立的節點（尾節點也是新建立的節點）
        else
            l.next = newNode;//將原來尾節點下一個節點的引用指向新節點
        size++;//節點數加1
        modCount++;//和ArrayList中同樣，iterator和listIterator方法返回的迭代器和列表迭代器實現使用。
    }

　　③、add(int index, E element)
　　將指定的元素插入此列表中的指定位置

//將指定的元素插入此列表中的指定位置
    public void add(int index, E element) {
        //判斷索引 index >= 0 && index <= size中時拋出IndexOutOfBoundsException異常
        checkPositionIndex(index);

        if (index == size)//若是索引值等於鏈表大小
            linkLast(element);//將節點插入到尾節點
        else
            linkBefore(element, node(index));
    }
    void linkLast(E e) {
        final Node<E> l = last;//將l設爲尾節點
        final Node<E> newNode = new Node<>(l, e, null);//構造一個新節點，節點上一個節點引用指向尾節點l
        last = newNode;//將尾節點設爲建立的新節點
        if (l == null)//若是尾節點爲空，表示原先鏈表爲空
            first = newNode;//將頭節點設爲新建立的節點（尾節點也是新建立的節點）
        else
            l.next = newNode;//將原來尾節點下一個節點的引用指向新節點
        size++;//節點數加1
        modCount++;//和ArrayList中同樣，iterator和listIterator方法返回的迭代器和列表迭代器實現使用。
    }
    Node<E> node(int index) {
        if (index < (size >> 1)) {//若是插入的索引在前半部分
            Node<E> x = first;//設x爲頭節點
            for (int i = 0; i < index; i++)//從開始節點到插入節點索引之間的全部節點向後移動一位
                x = x.next;
            return x;
        } else {//若是插入節點位置在後半部分
            Node<E> x = last;//將x設爲最後一個節點
            for (int i = size - 1; i > index; i--)//從最後節點到插入節點的索引位置之間的全部節點向前移動一位
                x = x.prev;
            return x;
        }
    }
    void linkBefore(E e, Node<E> succ) {
        final Node<E> pred = succ.prev;//將pred設爲插入節點的上一個節點
        final Node<E> newNode = new Node<>(pred, e, succ);//將新節點的上引用設爲pred,下引用設爲succ
        succ.prev = newNode;//succ的上一個節點的引用設爲新節點
        if (pred == null)//若是插入節點的上一個節點引用爲空
            first = newNode;//新節點就是頭節點
        else
            pred.next = newNode;//插入節點的下一個節點引用設爲新節點
        size++;
        modCount++;
    }

　　④、addAll(Collection<? extends E> c)
　　按照指定集合的迭代器返回的順序，將指定集合中的全部元素追加到此列表的末尾

　　此方法還有一個 addAll(int index, Collection<? extends E> c)，將集合 c 中全部元素插入到指定索引的位置。其實

　　　　addAll(Collection<? extends E> c) == addAll(size, Collection<? extends E> c)

　　源碼以下：

//按照指定集合的迭代器返回的順序，將指定集合中的全部元素追加到此列表的末尾。
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }
    //將集合 c 中全部元素插入到指定索引的位置。
    public boolean addAll(int index, Collection<? extends E> c) {
        //判斷索引 index >= 0 && index <= size中時拋出IndexOutOfBoundsException異常
        checkPositionIndex(index);

        Object[] a = c.toArray();//將集合轉換成一個 Object 類型的數組
        int numNew = a.length;
        if (numNew == 0)//若是添加的集合爲空，直接返回false
            return false;

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

　　看到上面向 LinkedList 集合中添加元素的各類方式，咱們發現LinkedList 每次添加元素只是改變元素的上一個指針引用和下一個指針引用，並且沒有擴容。，對比於 ArrayList ，須要擴容，並且在中間插入元素時，後面的全部元素都要移動一位，二者插入元素時的效率差別很大，下一篇博客會對這二者的效率，以及何種狀況選擇何種集合進行分析。

　　還有，每次進行添加操做，都有modCount++ 的操做。

五、刪除元素

　　刪除元素和添加元素同樣，也是經過更改指向上一個節點和指向下一個節點的引用便可，這裏就不做圖形展現了。

　　①、remove()和removeFirst()
　　今後列表中移除並返回第一個元素

//今後列表中移除並返回第一個元素
    public E remove() {
        return removeFirst();
    }
    //今後列表中移除並返回第一個元素
    public E removeFirst() {
        final Node<E> f = first;//f設爲頭結點
        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;//next 爲頭結點的下一個節點
        f.item = null;
        f.next = null; // 將節點的元素以及引用都設爲 null，便於垃圾回收
        first = next; //修改頭結點爲第二個節點
        if (next == null)//若是第二個節點爲空（當前鏈表只存在第一個元素）
            last = null;//那麼尾節點也置爲 null
        else
            next.prev = null;//若是第二個節點不爲空，那麼將第二個節點的上一個引用置爲 null
        size--;
        modCount++;
        return element;
    }

　　②、removeLast()
　　從該列表中刪除並返回最後一個元素

//從該列表中刪除並返回最後一個元素
    public E removeLast() {
        final Node<E> l = last;
        if (l == null)//若是尾節點爲空，表示當前集合爲空，拋出異常
            throw new NoSuchElementException();
        return unlinkLast(l);
    }
    
    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; //將節點的元素以及引用都設爲 null，便於垃圾回收
        last = prev;//尾節點爲倒數第二個節點
        if (prev == null)//若是倒數第二個節點爲null
            first = null;//那麼將節點也置爲 null
        else
            prev.next = null;//若是倒數第二個節點不爲空，那麼將倒數第二個節點的下一個引用置爲 null
        size--;
        modCount++;
        return element;
    }

　　③、remove(int index)
　　刪除此列表中指定位置的元素

//刪除此列表中指定位置的元素
    public E remove(int index) {
        //判斷索引 index >= 0 && index <= size中時拋出IndexOutOfBoundsException異常
        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) {//若是刪除節點位置的上一個節點引用爲null（表示刪除第一個元素）
            first = next;//將頭結點置爲第一個元素的下一個節點
        } else {//若是刪除節點位置的上一個節點引用不爲null
            prev.next = next;//將刪除節點的上一個節點的下一個節點引用指向刪除節點的下一個節點（去掉刪除節點）
            x.prev = null;//刪除節點的上一個節點引用置爲null
        }

        if (next == null) {//若是刪除節點的下一個節點引用爲null（表示刪除最後一個節點）
            last = prev;//將尾節點置爲刪除節點的上一個節點
        } else {//不是刪除尾節點
            next.prev = prev;//將刪除節點的下一個節點的上一個節點的引用指向刪除節點的上一個節點
            x.next = null;//將刪除節點的下一個節點引用置爲null
        }

        x.item = null;//刪除節點內容置爲null，便於垃圾回收
        size--;
        modCount++;
        return element;
    }

　　④、remove(Object o)
　　若是存在，則從該列表中刪除指定元素的第一次出現

　　此方法本質上和 remove(int index) 沒多大區別，經過循環判斷元素進行刪除，須要注意的是，是刪除第一次出現的元素，不是全部的。

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

六、修改元素

　　經過調用 set(int index, E element) 方法，用指定的元素替換此列表中指定位置的元素。

public E set(int index, E element) {
        //判斷索引 index >= 0 && index <= size中時拋出IndexOutOfBoundsException異常
        checkElementIndex(index);
        Node<E> x = node(index);//獲取指定索引處的元素
        E oldVal = x.item;
        x.item = element;//將指定位置的元素替換成要修改的元素
        return oldVal;//返回指定索引位置原來的元素
    }

　　這裏主要是經過 node(index) 方法獲取指定索引位置的節點，而後修改此節點位置的元素便可。

七、查找元素

　　①、getFirst()
　　返回此列表中的第一個元素

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

　　②、getLast()
　　返回此列表中的最後一個元素

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

　　③、get(int index)
　　返回指定索引處的元素

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

　　④、indexOf(Object o)
　　返回此列表中指定元素第一次出現的索引，若是此列表不包含元素，則返回-1。

//返回此列表中指定元素第一次出現的索引，若是此列表不包含元素，則返回-1。
    public int indexOf(Object o) {
        int index = 0;
        if (o == null) {//若是查找的元素爲null(LinkedList能夠容許null值)
            for (Node<E> x = first; x != null; x = x.next) {//從頭結點開始不斷向下一個節點進行遍歷
                if (x.item == null)
                    return index;
                index++;
            }
        } else {//若是查找的元素不爲null
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;//找不到返回-1
    }

八、遍歷集合

　　①、普通 for 循環

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
linkedList.add("D");
for(int i = 0 ; i < linkedList.size() ; i++){
    System.out.print(linkedList.get(i)+" ");//A B C D
}

　　代碼很簡單，咱們就利用 LinkedList 的 get(int index) 方法，遍歷出全部的元素。

　　可是須要注意的是， get(int index) 方法每次都要遍歷該索引以前的全部元素，這句話這麼理解：

　　好比上面的一個 LinkedList 集合，我放入了 A,B,C,D是個元素。總共須要四次遍歷：

　　第一次遍歷打印 A：只需遍歷一次。

　　第二次遍歷打印 B：須要先找到 A，而後再找到 B 打印。

　　第三次遍歷打印 C：須要先找到 A，而後找到 B，最後找到 C 打印。

　　第四次遍歷打印 D：須要先找到 A，而後找到 B，而後找到 C，最後找到 D。

　　這樣若是集合元素不少，越查找到後面（固然此處的get方法進行了優化，查找前半部分從前面開始遍歷，查找後半部分從後面開始遍歷，可是須要的時間仍是不少）花費的時間越多。那麼如何改進呢？

　　②、迭代器

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
linkedList.add("D");


Iterator<String> listIt = linkedList.listIterator();
while(listIt.hasNext()){
    System.out.print(listIt.next()+" ");//A B C D
}

//經過適配器模式實現的接口，做用是倒敘打印鏈表
Iterator<String> it = linkedList.descendingIterator();
while(it.hasNext()){
    System.out.print(it.next()+" ");//D C B A
}

　　在 LinkedList 集合中也有一個內部類 ListItr，方法實現大致上也差很少，經過移動遊標指向每一次要遍歷的元素，不用在遍歷某個元素以前都要從頭開始。其方法實現也比較簡單：

public ListIterator<E> listIterator(int index) {
        checkPositionIndex(index);
        return new ListItr(index);
    }

    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 boolean hasNext() {
            return nextIndex < size;
        }

        public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();

            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }

        public boolean hasPrevious() {
            return nextIndex > 0;
        }

        public E previous() {
            checkForComodification();
            if (!hasPrevious())
                throw new NoSuchElementException();

            lastReturned = next = (next == null) ? last : next.prev;
            nextIndex--;
            return lastReturned.item;
        }

        public int nextIndex() {
            return nextIndex;
        }

        public int previousIndex() {
            return nextIndex - 1;
        }

        public void remove() {
            checkForComodification();
            if (lastReturned == null)
                throw new IllegalStateException();

            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount++;
        }

        public void set(E e) {
            if (lastReturned == null)
                throw new IllegalStateException();
            checkForComodification();
            lastReturned.item = e;
        }

        public void add(E e) {
            checkForComodification();
            lastReturned = null;
            if (next == null)
                linkLast(e);
            else
                linkBefore(e, next);
            nextIndex++;
            expectedModCount++;
        }

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

　　這裏須要重點注意的是 modCount 字段，前面咱們在增長和刪除元素的時候，都會進行自增操做 modCount，這是由於若是想一邊迭代，一邊用集合自帶的方法進行刪除或者新增操做，都會拋出異常。（使用迭代器的增刪方法不會拋異常）

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

　　好比：

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
linkedList.add("D");


Iterator<String> listIt = linkedList.listIterator();
while(listIt.hasNext()){
    System.out.print(listIt.next()+" ");//A B C D
    //linkedList.remove();//此處會拋出異常
    listIt.remove();//這樣能夠進行刪除操做
}

　　迭代器的另外一種形式就是使用 foreach 循環，底層實現也是使用的迭代器，這裏咱們就不作介紹了。

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
linkedList.add("D");
for(String str : linkedList){
    System.out.print(str + "");
}

九、迭代器和for循環效率差別

LinkedList<Integer> linkedList = new LinkedList<>();
for(int i = 0 ; i < 10000 ; i++){//向鏈表中添加一萬個元素
    linkedList.add(i);
}
long beginTimeFor = System.currentTimeMillis();
for(int i = 0 ; i < 10000 ; i++){
    System.out.print(linkedList.get(i));
}
long endTimeFor = System.currentTimeMillis();
System.out.println("使用普通for循環遍歷10000個元素須要的時間："+ (endTimeFor - beginTimeFor));


long beginTimeIte = System.currentTimeMillis();
Iterator<Integer> it = linkedList.listIterator();
while(it.hasNext()){
    System.out.print(it.next()+" ");
}
long endTimeIte = System.currentTimeMillis();
System.out.println("使用迭代器遍歷10000個元素須要的時間："+ (endTimeIte - beginTimeIte));

　　打印結果爲：

　　一萬個元素二者之間都相差一倍多的時間，若是是十萬，百萬個元素，那麼二者之間相差的速度會愈來愈大。下面經過圖形來解釋：