带你走进Java集合_LinkedList源码深入分析2

    上一篇文章,我们主要介绍了LinkedList的基本操作,我们要掌握以下知识点:

1)LinkedList的底层数据结构是双向链表

2)LinkedList可以添加任何的元素,包括null

3)LinkedList在多线程下作为共享数据是不安全的。

4)LinkedList把添加的数据封装成了Node,包含前驱prev,后继next,值val

这一篇文章,我们从源码角度去了解LinkedList的其他几类方法,这些方法都是protect和private,我们在使用LinkedList是不能直接使用的,但是我们调用的add/remove等公开的方法内部都是调用的这些方法

一、第一类方法:1)插入到头结点,2)插入到中间,3)插入到末尾,说白了,这些方法都是对链表的操作,懂得链表的操作,非常好理解的

1)插入到头结点:linkFirst

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

在LinkedList的api中提供了插入链表首节点的方法:addFirst(E e),内部直接调用的这个linkFirst方法,我们分析一下它的源码:

(1)获取到插入e前的first的节点f

(2)创建新的头结点newNode,newNode的后继节点next=f,即newNode.next=f

(3)将新创建的节点newNode赋值给头结点first

(4)判断插入前头结点f是否为null,如果是则说明链表中还没有元素,newNode就是第一个元素,则last=newNode

(5)如果f!=null,则将newNode赋值给插入前头结点f的前驱,即f.prev=newNode

举例说明:

如果插入newNode前,链表是空的。

《带你走进Java集合_LinkedList源码深入分析2》

如果插入newNode前,链表不为空,即f!=null

《带你走进Java集合_LinkedList源码深入分析2》

2)插入到中间:linkBefore(E e,Node succ)

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

这个方法主要就是将新增元素插入非空节点succ之前,LinkedList的api内部调用这个方法的有:add(index,e)

1)插入节点succ之前,则需要获取succ的前驱pred,我们知道succ一定是存在的,但是pred可能不存在,例如如果succ是首节点的话,则pred=null

2)将新增的元素封装成Node,其中newNode.prev=pred,newNode.next=succ,就是在pred和succ之间插入元素

3)将succ的前驱pred  succ.prev=newNode

4)如果pred==null的话,说明succ插入前是首节点,只需将first=newNode即可

5)如果pred!=null的话,则说明succ前还有节点,需要将pred.next=newNode

举例说明:

如果插入newNode前,succ是首节点,即pred=null,这时和linkFirst中f!=null相同

《带你走进Java集合_LinkedList源码深入分析2》

如果插入newNode前,succ不是首节点,则pred!=null

《带你走进Java集合_LinkedList源码深入分析2》

3)插入末尾:linkLast(E e)

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

这个方法是api中add(e)和addLast(e)方法的内部实现,就是将一个新元素插入到链表的结尾

(1)获取最后一个节点l

(2)封装新插入的元素Node,将newNode.prev=l

(3)将newNode赋值给尾节点,即last=newNode

(4)如果l==null,则执行first=newNode

(5)如果l!=null,则执行l.next=newNode

举例说明:

如果l==null,说明此时链表是空链表,和linkFirst中f==null时相同

《带你走进Java集合_LinkedList源码深入分析2》

如果l!=null,则newNode要插入到末尾

《带你走进Java集合_LinkedList源码深入分析2》

以上3中就是LinkedList集合插入元素的底层实现,我们不能直接调用这些方法,但是LinkedList给我们提供的api都是调用这些底层方法的,所以我们调用LinkedList的add(e)、add(index,e),addFirst(e)、addLast(e)等方法时,底层调用的就是这三类方法

二、第二类方法:1)删除头结点,2)删除中间节点,3)删除尾节点

1)删除头结点:unLinkFirst(Node 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;
    }

这个方法是LinkedList提供的api方法remove()、removeFirst()、poll(),pollFirst()等方法的底层实现

(1)获取要删除头结点的值element

(2)获取要删除的头结点的后继节点next,next可能是null,可能不是null

(3)将删除的节点item=null,next=null,便于垃圾回收

(4)讲first=next

(5)如果next==null则说明链表只有一个节点,删除后就是空链表了,所以next=null

(6)如果next!=null则说明删除前不只是一个节点,所以将next.prev=null,因为next现在变成首节点了,首节点的前驱为null,所以next.prev=null

举例说明:

如果next=null时,删除f节点后,LinkedList链表就变成空链表了

《带你走进Java集合_LinkedList源码深入分析2》

如果next!=null时,说明删除f节点后,LinkedList中还有元素

《带你走进Java集合_LinkedList源码深入分析2》

2)删除中间节点:unLink(Node x)

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

这个方法是LinkedList提供的api方法remove(Object o)、remove(index)等方法的底层实现

(1)因为要删除中间节点,所以需要知道要删除节点x的前驱prev,也要知道要删除节点的后继next

(2)如果prev==null,则说明删除的节点是头结点,则执行first=next

(3)如果prev!=nul,则说明删除的节点不是头结点,则执行prev.next=next,x.prev=null

(4)如果next==null,则说明删除的节点是尾节点,则执行last=prev

(5)如果next!=null,则说明删除的节点不是尾节点,则执行next.prev=prev,x.next=null

(3)中的x.prev=null和(5)中的x.next=null表示就是将删除节点的前驱和后继变成null,以便GC,其实删除头结点和尾节点也可以直接调用此方法。

《带你走进Java集合_LinkedList源码深入分析2》

说明,prev和next可能为null

3)删除尾节点:unLinkLast(Node 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; // help GC
        last = prev;
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

这个方法是LinkedList提供的api中removeLast,pollLast,的底层实现

(1)获取到尾节点的前驱prev

(2)将l.item=null,l.prev=null(以便GC )

(3)将last=prev,将尾节点指向prev

(4)如果prev==null,则说明链表中只有一个节点,删除后就是空链表了,所以first=null

(5)如果prev!=null,说明链表中有多于一个节点,删除后prev变成了尾节点,所以prev.next=null

《带你走进Java集合_LinkedList源码深入分析2》

这一篇文章主要从源码角度分析了LinkedList给我们提供的api的底层实现,无非就是对链表的插入和删除,只要对链表非常的熟悉,相信LinkedList是非常容易理解的。更多JDK源码分析请持续关注。

    原文作者:java集合源码分析
    原文地址: https://blog.csdn.net/shaotianqiang/article/details/80666746
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞