App下載

Java中LinkedList容器的整體結構 源碼解析LinkedList的使用

綠水無憂 2021-08-10 11:47:21 瀏覽數(shù) (1866)
反饋

一、LinkedList的整體結構

1.1、LinkedList的繼承關系

  • public class LinkedList<E> extends AbstractSequentialList <E> implements List<E>, Deque<E>
  • LinkedList具備AbstractSequentialList的特點:AbstractSequentialList 只支持按次序訪問,而不像 AbstractList 那樣支持隨機訪問
  • LinkedList具備List的特點
  • LinkedList具備Deque的特點:Deque是一個線性collection,支持在兩端插入和移除元素

1.2、LinkedList的結構

//元素個數(shù)
transient int size = 0;
//第一個元素指針
transient Node<E> first;
//最后一個元素指針
transient Node<E> last;
//Node節(jié)點的結構
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;
    }
}

1.2.1 Node的結構

LinkedList結構


LinkedList特點

1.LinkedList是通過雙鏈表去實現(xiàn)的。

2.LinkedList不存在容量不足的問題,因為是鏈表。

3.LinkedList實現(xiàn)了Deque,而Deque接口定義了在雙端隊列兩端訪問元素的方法,所以LinkedList可以作為FIFO(先進先出)的隊列;LinkedList可以作為LIFO(后進先出)的棧

 二、源碼分析

2.1、添加元素

//添加元素
public boolean add(E e) {
    //默認調(diào)用,尾部添加元素的方法
    linkLast(e);
    return true;
}
//尾部添加元素
void linkLast(E e) {
    //記錄當前尾部元素
    final Node<E> l = last;
    //創(chuàng)建一個新的Node節(jié)點 ,prev是當前的尾節(jié)點,next指向null
    final Node<E> newNode = new Node<>(l, e, null);
    //將last設置為新節(jié)點
    last = newNode;
    //判斷當前尾部節(jié)點是否為null
    if (l == null)
        //當前尾部節(jié)點為null,就掛到頭結點上
        first = newNode;
    else
        //當前尾部節(jié)點不為null,就將新建的Node掛到當前l(fā)ast節(jié)點的next指針上
        l.next = newNode;
    //元素的個數(shù)+1
    size++;
    //LinkedList修改記錄+1
    modCount++;
}

新增元素add()方法默認是尾部追加,核心就是將新建的Node節(jié)點追加到當前l(fā)ast節(jié)點的next指針上 ,偽代碼:

Node newNode=new Node();
newNode.prev=last;
last.next=newNode;
last=newNode;
last.next=null;

addFirst:首部追加

public void addFirst(E e) {
    linkFirst(e);
}
//頭部追加
private void linkFirst(E e) {
    //記錄當前首部元素
    final Node<E> f = first;
    //新建一個Node節(jié)點
    final Node<E> newNode = new Node<>(null, e, f);
    //首部元素指向新建的節(jié)點
    first = newNode;
    //判斷當前首部指針是否為null
    if (f == null)
        //當前首部指針為null,就把新建的節(jié)點掛到last指針上
        last = newNode;
    else
        //當前首部指針不為null,就把新建的節(jié)點掛到,當前first指針指向元素的prev指針上
        f.prev = newNode;
    //元素個數(shù)+1
    size++;
    //LinkedList修改記錄+1
    modCount++;
}

首部追加的邏輯與尾部追加基本相同,偽代碼:

Node newNode=new Node();
newNode.next=first;
first.prev=newNode;
first=newNode;
first.prev=null;(也可以:newNode.prev=null)

指定位置添加元素:add(int index, E element):

public void add(int index, E element) {
    //檢查要插入的位置是否合法
    checkPositionIndex(index);
    //如要插入的位置在最后,直接調(diào)用linkLast()
    if (index == size)
        linkLast(element);
    else
        //如要插入的位置不在最后,就先查找再插入
        linkBefore(element, node(index));
}
 
//查找要插入元素的位置
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;
    }
}
//將新建的元素插入到查找的元素前面
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是一個雙向鏈表,他只記錄了頭部和尾部位置,如果我們要指定位置插入,他會這么做:

1.先遍歷查找出要插入的元素位置,然后再插入;查找方式是根據(jù) index < (size >> 1) 判斷結果,決定是從頭遍歷,還是從尾部遍歷,這種遍歷方式類似于二分查找(只在第一層循環(huán)二分)

2.新建一個Node節(jié)點,插入到查找出來的元素的前面

由此可知為何鏈表對隨機位置讀寫是不合適的;他的時間復雜度=O(n/2) ,如果n很大,我們一般就認為他的時間復雜度=O(n)

2.2、刪除元素

//重寫List的remove()
public boolean remove(Object o) {
    if (o == null) {
        //如果要刪除的元素null元素,從頭開始查找這個null元素
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
         //如果要刪除的元素不null元素,從頭開始查找這個非null元素
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}
//執(zhí)行刪除邏輯,實質就是打斷改元素與鏈表的引用關系
E unlink(Node<E> x) {
    // assert x != null;
    //記錄改元素的值,實際作用就是做返回值
    final E element = x.item;
    //記錄當前元素的下一個節(jié)點
    final Node<E> next = x.next;
    //記錄當前元素的上一個節(jié)點
    final Node<E> prev = x.prev;
    //判斷 x->prev 節(jié)點是否為null,為null就是刪除頭結點 
    if (prev == null) {
        first = next;
    } else {
        //將 x->prev節(jié)點的next指針指向x節(jié)點的下一個節(jié)點
        prev.next = next;
        //將 x->prev 指針,設置為null(斷開引用關系)
        x.prev = null;
    }
     //判斷 x->next 節(jié)點是否為null,為null就是刪尾部結點 
    if (next == null) {
        last = prev;
    } else {
        //將x->next節(jié)點的prev指針指向x->prev
        next.prev = prev;
        //將 x->next指針,設置為null(斷開引用關系)
        x.next = null;
    }
    //將x的值設置為null
    x.item = null;
    //集合大小-1
    size--;
    //集合的修改記錄-1
    modCount++;
    return element;
}

這里我們看到LinkedList重寫了List的remove方法,整個刪除邏輯也是先查找再刪除,時間復雜度O(n),如果是刪除首部元素時間復雜度=O(1),若要刪除尾部元素請使用removeLast( ) 

  • LinkedLis刪除首部元素:removeFirst()
  • LinkedLis刪除尾部元素:removeLast()
  • LinkedLis首部出隊:pollFirst( ) ,隊列的特點
  • LinkedLit尾部出隊:pollLast( ),隊列的特點

2.3、迭代器

Iterator迭代器只能是從頭往尾迭代,而LinkedList是雙向鏈表,他還可以從尾往頭部迭代,JAVA提供了一個新的迭代器接口:

public interface ListIterator<E> extends Iterator<E>{
    //判斷是否存在下一個元素
    boolean hasNext();
    //獲取下一個元素
    E next();
    //判斷是否還有前一個元素
    boolean hasPrevious();
    //獲取前一個元素
    E previous();
}

LinkedList實現(xiàn)該接口:

private class ListItr implements ListIterator<E> {
    private Node<E> lastReturned;//上一次next() 或者 previous()的元素
    private Node<E> next;//lastReturned->next 指向的元素
    private int nextIndex;//下一個元素的位置
    private int expectedModCount = modCount;
}

LinkedList從前往后遍歷:

//是否存在下一個元素
public boolean hasNext() {
    return nextIndex < size;
}
public E next() {
    //檢查集合的版本
    checkForComodification();
    if (!hasNext())
        throw new NoSuchElementException();
    //lastReturned賦值上次next
    lastReturned = next;
    //next賦值為上次next->next
    next = next.next;
    //下一個元素的位置
    nextIndex++;
    return lastReturned.item;
}

LinkedList從后往前遍歷:

//判斷是否到頭了
public boolean hasPrevious() {
    return nextIndex > 0;
}
//從尾部往頭部取數(shù)據(jù)
public E previous() {
    checkForComodification();
    if (!hasPrevious())
        throw new NoSuchElementException();
    // next==null:第一次遍歷取尾節(jié)點(last),或者上一次遍歷時把尾節(jié)點刪除掉了
    // next!=null:已經(jīng)發(fā)生過遍歷了,直接取前一個節(jié)點即可(next.prev)
    lastReturned = next = (next == null) ? last : next.prev;
    //遍歷的指針-1
    nextIndex--;
    return lastReturned.item;
}

迭代器刪除元素:

public void remove() {
    checkForComodification();
    // lastReturned 是本次迭代需要刪除的值
    // lastReturned==null則調(diào)用者沒有主動執(zhí)行過 next() 或者 previos(),二直接調(diào)remove()
    // lastReturned!=null,是在上次執(zhí)行 next() 或者 previos()方法時賦的值
    if (lastReturned == null)
        throw new IllegalStateException();
    //保存將當前要刪除節(jié)點的下一個節(jié)點(如果是從尾往頭遍歷,該值永遠是null)
    Node<E> lastNext = lastReturned.next;
    //刪除當前節(jié)點
    unlink(lastReturned);
 
    // next == lastReturned:從尾到頭遞歸順序,并且是第一次迭代,并且要刪除最后一個元素的情況下,
    // previous() 方法里面設置了 lastReturned = next = last,所以 next 和 lastReturned會相等
    if (next == lastReturned)
        next = lastNext;
    else
        nextIndex--;
    lastReturned = null;
    expectedModCount++;
}

三、總結

LinkedList底層數(shù)據(jù)結構是雙向鏈表,所以他更適合順序操作,由于他繼承了Deque接口,同時他具有隊列的性質,非線程安全的集合

到這里,本篇關于Java中LinkedList容器的整體結構和使用方法的內(nèi)容就介紹完了,想要了解更多相關Java容器LinkedList內(nèi)容,請搜索W3Cschool以前的文章或繼續(xù)瀏覽下面的相關文章!

0 人點贊