LinkdedList源码解析

我实在太想进步了

已于 2024-08-09 11:28:56 修改

阅读量676

点赞数 17

分类专栏： Java集合文章标签： java

于 2024-08-09 11:26:34 首次发布

本文链接：https://blog.csdn.net/m0_63581570/article/details/141057231

版权

Java集合专栏收录该内容

3 篇文章 0 订阅

订阅专栏

LinkedList源码解析

LinkedList结构

在这里插入图片描述
LinkedList实现了List、Deque、Cloneable接口，同时继承了AbstractSequentialList。这个AbstractSequentialList我们不熟，但实现了List，Deque(双端队列)这两个接口就意味着要实现get()、set()、remove()、getFirst 、 pollFirst、 pollLast等函数。

LinkedList的内部类

在这里插入图片描述

ListItr、LLSpliterator、DescendingIterator都是为LinkedList提供更多的遍历方式和处理元素方式。因为ListItr和LLSpliterator都实现了ListIterator接口，而LLSpliterator实现了Spliterator<E>，为了LinkedList提供了Stream流的支持。

而Node类就是LinkedList用来存储元素的(链表)

在这里插入图片描述

LinkedList如何实现功能

在源码中我们可以看到这几个字段

在这里插入图片描述

而 Node<E> first 和Node<E> last 再结合Node这个内部类就说明了LinkedList是基于双向链表来实现上述的功能的。

LinkedList是如何添加一个元素

不指定位置插入

LinkedList<Integer> list = new LinkedList<>();
list.add(1);

在这个无参构造函数中LinkedList什么操作也没有

/**
     * Constructs an empty list.
     */
public LinkedList() {
}

然后我们进入add方法中发现它调用的实际是linklast(E e)

public boolean add(E e) {
    linkLast(e);
    return true;
}
/**
* Links e as last element. 添加元素到最后
*/
void linkLast(E e) {
    //将尾节点赋值给l 
    final Node<E> l = last;
    //新建节点 这个节点的前一个指向l 这时l是null 后一个指向null
    final Node<E> newNode = new Node<>(l, e, null);
    //再将newNode赋给last
    last = newNode;
    if (l == null)
        //头节点指向newNode
        first = newNode;
    else
        l.next = newNode;
    //此时头节点和尾节点都指向该节点并
    size++;
    modCount++;
}
    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++;
    }

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

如果此时再添加一个元素

在这里插入图片描述

可以看出经典的尾插法

指定位置插入

public void add(int index, E element) {
    checkPositionIndex(index);
	//继续尾插
    if (index == size)
        linkLast(element);
    else
        //先查找这个下标对应的元素
        linkBefore(element, node(index));
}	
	//充分利用双向链表的性质
    Node<E> node(int index) {
        // assert isElementIndex(index);
		//index < size 的二分之一
        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;
        }
    }

知道该下标对应的节点后进行插入就很简单了

LinkedList是如何查询，删除一个元素的

对于查询、删除首尾节点，双向链表可以很快的实现,时间复杂度O(1)。这里就不介绍了，而查询指定位置的元素再前面也介绍过了。

这里我们就来讲讲删除指定位置节点，时间复杂度O(n)

/**
     *删除此列表中指定位置处的元素。将任何后续元素向左移动（从其索引中减去 1）。返回已从列表中删除的元素.
     */
public E remove(int index) {
    checkElementIndex(index);
    //先找出该位置的节点
    return unlink(node(index));
}
E unlink(Node<E> x) {
    // 确保传入的节点不为 null
    // assert x != null;

    // 保存节点的值，以便返回
    final E element = x.item;

    // 获取当前节点的前后节点
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    // 处理前驱节点为空的情况（即 x 是头节点）
    if (prev == null) {
        // 将链表的头节点移到下一个节点
        first = next;
    } else {
        // 将前驱节点的 next 指向当前节点的后继节点
        prev.next = next;
        // 断开当前节点与前驱节点的链接
        x.prev = null;
    }
    // 处理后继节点为空的情况（即 x 是尾节点）
    if (next == null) {
        // 将链表的尾节点移到前一个节点
        last = prev;
    } else {
        // 将后继节点的 prev 指向当前节点的前驱节点
        next.prev = prev;
        // 断开当前节点与后继节点的链接
        x.next = null;
    }
    // 将当前节点的数据域清空，以便垃圾回收
    x.item = null;
    size--;
    modCount++;
    return element;
}