LinkedList源码解析

已于 2022-08-07 18:19:39 修改
阅读量750 收藏 5
点赞数 1
文章标签： 链表 数据结构 算法
于 2022-08-07 18:17:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32073629/article/details/126214942
版权

LinkedList集合同时具有List集合和Queue集合的基本特征。

在这里插入图片描述

通过上面继承体系可以知道，LinkedList同时实现了List接口和Queue接口，这两个接口分别代表了JCF中三大集合结构(List、Queue、Set)中的两个。在JDK1.2版本后，JDK1.6版本前，官方推荐使用LinkedList集合模拟栈结构

LinkedList集合的主要结构是双向链表。双向链表中的节点把要求有连续的内存存储地址，因此在向双向链表中插入新节点的时候，无须申请一块连续的存储空间，只需按需申请存储空间，LinkedList集合中的链表的每个节点都使用一个java.util.LinkedList.Node类的对象进行描述

private static class Node<E> {
    //主要用于在当前Node节点上的存储的数据对象
    E item;
    //类型也是Node，表示当前节点指向的下一个节点
    Node<E> next;
    //类型也是Node，表示当前节点指向的上一个节点
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

LinkedList集合使用first属性来记录双向链表的头节点，使用last属性；哎记录双向链表的尾节点，使用size变量来记录双向链表的当前长度。源码片段如下：

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    //记录当前双向链表的长度
    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;

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

first == null && last == null：当双向链表没有任何数据对象的时候，first属性和last属性都为null

first == last：当双向链表只有一个对象的时候，first属性和last属性一定指向同一个节点

first != null && last != null：当双向链表至少有一个数据对象的时候，first属性和last属性都不可能为null

LinkedList集合内部场景是不可能出现（first != null && last == null）或者（first == null && last != null）。因为first属性和last属性要么都为null，要么都不为null

JDK1.8开始，LinkedList集合中有3个用于在链表的不同位置添加新的节点，分别是linkFirst(E)方法，linkLast(E)方法和linkBefore(E,Node)方法

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

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

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修饰的方法，这些方法要通过add(E)、addLast(E)、addFirst(E)等方法进行封装，才能对外提供服务

public boolean add(E e) {
    linkLast(e);
    return true;
}

public void addLast(E e) {
    linkLast(e);
}

public void addFirst(E e) {
    linkFirst(e);
}

首先看一下linkFirst(E)方法，linkFirst(E)方法可以在双向链表的头部添加一个新的Node节点，用于存储新添加的数据对象，并且调整当前first属性的指向位置

/**
 * Links e as first element.
 */
private void linkFirst(E e) {
    //使用一个临时的变量记录操作前first属性的信息
    final Node<E> f = first;
    //创建一个数据信息为e的新节点，该节点前置节点引用为null，后置节点引用指向原先的头节点
    final Node<E> newNode = new Node<>(null, e, f);
    //因为要在双向链表头部添加新的节点，将first属性中的信息重新设置
    first = newNode;
    //条件成立，说明双向链表没有任何节点
    if (f == null)
        //将last节点也指向新的节点，这样first和last节点属性同时指向同一个节点
        last = newNode;
    else
        //不成立，说明双向链表至少有一个节点，只需要把原来的头节点的前置节点引用指向新的头节点
        f.prev = newNode;
    //双向链表长度 + 1
    size++;
    //linkedList集合的操作次数 + 1
    modCount++;
}

linkLast(E)方法可以在当前双向链表的尾节点之后添加一个新的节点，并且调整last属性的指向位置

void linkLast(E e) {
    //使用一个临时变量来记录操作前的last属性信息
    final Node<E> l = last;
    //创建一个新的节点，item属性值为e，新节点的前置对象指向原来的尾节点，后置节点为null
    final Node<E> newNode = new Node<>(l, e, null);
    //因为要在双向链表的尾节点添加新的节点，将last属性中的信息重新设置
    last = newNode;
    //条件成立，说明双向链表没有任何节点
    if (l == null)
        //将first节点指向新的节点，first和last都同时指向同一个节点
        first = newNode;
    else
        //不成立，双向链表至少有一个节点，将原来的尾节点的后置节点指向新的尾节点
        l.next = newNode;
    //双向链表长度 + 1 
    size++;
    //linkedList集合的操作次数 + 1
    modCount++;
}

linkBefore(E,Node) 方法可以在指定的节点前的索引位置上插入一个新的节点，注意的是，LinkedList集合的操作逻辑可以保证这里的succ入参一定不为null，并且一定已经存储于当前LinkedList集合中的某个位置

void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    //创建一个变量，记录当前succ的前置节点引用(可能为null)
    final Node<E> pred = succ.prev;
    //创建一个新的节点，该节点的前置节点引用指向succ节点的前置节点，该节点的后置节点引用指向succ节点
    final Node<E> newNode = new Node<>(pred, e, succ);
    //将succ节点的前置节点重新设置为刚刚创建的新的节点
    succ.prev = newNode;
    //条件成立，说明当前succ节点原本就是双向链表的头节点，可以看作当前的操作其实就是在链表的头部添加一个新的节点
    if (pred == null)
        //这个时候将first属性的指向新创建的节点
        first = newNode;
    else
        //不成立，将succ的前置节点的后置节点设置为当前新创建的节点
        pred.next = newNode;
    //双向链表长度 + 1
    size++;
    //linkedList集合的操作次数 + 1
    modCount++;
}

​ LinkedList集合中有3个移除集合中数据对象的方法，unlinkFirst(Node)方法、unlinkLast(Node)方法、unlink(Node)方法，LinkedList集合中提过了3个对外封装好的方法removeFirst()、removeLast()、remove(Object)

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

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

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

使用unlinkFirst(Node)方法可以移除LinkedList集合中双向链表的头节点，并且重新设置它的后置节点为新的头节点，该方法入参 f 就是当前双向链表的头节点，该参数一定不为null

private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    //定义一个element变量，记录当前双向链表头节点的数据对象，以便方法最后将其返回
    final E element = f.item;
    //创建一个next变量，记录当前双向链表头节点的后置节点引用，可能为null
    final Node<E> next = f.next;
    //设置当前双向链表头节点的数据对象为null，后置节点引用设置为null
    f.item = null;
    f.next = null; // help GC  (帮助进行GC（java的垃圾回收机制）)
    //设置双向链表新的头节点为当前头节点的后置节点
    first = next;
    //条件处理，说明完成头节点的移除操作，当前双向链表已经没有任何节点
    if (next == null)
        //将last属性设置为null
        last = null;
    else
        //不成立，设置新的头节点前置节点设置为null，因为新的头节点的前置节点指向是原先的头节点
        next.prev = null;
    //双向链表长度 - 1
    size--;
    //LinkedList集合操作次数 + 1 
    modCount++;
    return element;
}

unlinkLast(Node)方法可以移除LinkedList集合中双向链表的尾节点，并且重新设置它的前置节点为新的尾节点，该方法入参 l 就是当前双向链表的尾节点，该参数一定不为null

private E unlinkLast(Node<E> l) {
    // assert l == last && l != null;
    //定义一个element变量记录当前双向链表尾节点中的数据对象，以便在最后将其返回
    final E element = l.item;
    //创建一个prev变量，记录当前双向链表尾节点中的前置节点，该变量可能为null
    final Node<E> prev = l.prev;
    //设置当前双向链表尾节点中的数据为null，前置对象引用为null
    l.item = null;
    l.prev = null; // help GC  帮助进行GC（垃圾回收）
    //设置双向链表新的尾节点为当前尾节点的前置节点
    last = prev;
    //条件处理，说明移除完尾节点之后双向链表已经没有任何节点了
    if (prev == null)
        //设置头节点为null
        first = null;
    else
        //不成立，设置新的尾节点后置节点设置为null，因为新的尾节点的后置节点指向是原先的尾节点
        prev.next = null;
    //双向链表长度 - 1
    size--;
    //LinkedList集合操作次数 + 1
    modCount++;
    return element;
}

unlink(Node)方法可以从双向链表中移除指定的节点，其入参x所指向的节点一定位于双向链表中

E unlink(Node<E> x) {
    // assert x != null;
    //定义一个element变量，记录当前节点中的数据对象，以便方法最后返回
    final E element = x.item;
    //创建一个next节点，记录当前节点中的后置节点引用，可能为null
    final Node<E> next = x.next;
    //创建一个prev节点，记录当前节点中的前置节点引用，可能为null
    final Node<E> prev = x.prev;

    //如果条件成立，说明被移除的x节点是双向链表的头节点
    if (prev == null) {
        //将x的后置节点设置为新的头节点
        first = next;
    } else {
        //将x的前置节点中的后置节点设置为移除的x节点的后置节点
        prev.next = next;
        //将移除的x节点的前置节点设置为null
        x.prev = null;
    }

    //如果条件成立，说明被移除的x节点是双向链表的尾节点
    if (next == null) {
        //将移除的x的节点的前置节点设置为新的尾节点
        last = prev;
    } else {
        //将x的后置节点中的前置节点设置为移除x节点的前置节点
        next.prev = prev;
        //将移除的x节点的后置节点设置为null
        x.next = null;
    }

    //将移除的x节点中的数据对象设置为null
    x.item = null;
    //双向链表长度 - 1
    size--;
    //LinkedList集合操作次数 + 1
    modCount++;
    return element;
}

LinkedList集合中的其他方法调用linkBefore(E,Node)方法插入新的节点或者调用unlink(Node)方法移除指定的节点的时候，都需要先找到这个要被操作的节点，由于双向链表的构造结构，LinkedList集合不能跟ArrayList集合一样，通过指定的一个数值便可以定位到指定的索引位，双向链表查询指定的索引位的方式，就是从头节点或者尾节点开始进行遍历，实现的方法在java.util.LinkedList集合中的node(int)方法

​ node方法返回的结果不为null，入参index为当前操作要查询的节点索引值，开始index值为0

Node<E> node(int index) {
    // assert isElementIndex(index);

    //如果条件成立，说明当前指定的index号索引位在当前双向链表的前半段
    if (index < (size >> 1)) {
        //从当前双向链表的头节点开始向后依次查询
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        //不成立，说明当前指定的index号索引位在双向链表的后半段，从当前双向链表的尾节点开始向后依次查询
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

node(int)方法在LinkedList集合中的使用具有普遍性，addAll(int,Collection)方法，get(int)方法，set(int,E)方法，add(int,E)方法，remove(int)方法等的读或写操作都使用node(int)方法查询双向链表中的指定的索引位

有一些方法比较特殊，如indexOf(Object)方法，lastIndexOf(Object)方法，remove(Object)方法，这种方法不是使用node(int)方法查询索引位，它们使用的数据对象引用信息来查询指定的索引位，以indexOf(Object)为例子，源码如下

indexOf(Object)方法主要用于双向链表的头节点开始，查询离0号索引位最近的一个节点，这个节点的特点是，item属性存储的数据信息(引用地址)等于当前入参o所代表的数据信息(引用地址)，该方法规定，如果当前入参o为null，则查询离头节点最近的item属性为null的节点，如果没有找到符合条件的节点，该方法返回-1

public int indexOf(Object o) {
    int index = 0;
    //如果入参o为null
    if (o == null) {
        //从头节点开始向后遍历，直到找到某个item属性值为null的节点
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } else {
        //不为null，从头节点开始向后遍历，直到找到某个item属性值向的内存地址和传入参数o指向的内存地址相同的节点
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    return -1;
}
一位潜水的码农
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
深入剖析LinkedList的底层源码，再也不怕面试官问了！，2024年最新mysql事务隔离级别面试
2401_84002409的博客
04-13 423
其中，调用了linkLast()方法，设置元素e为最后一个元素/***/void linkLast(E e) {// 获取链表的最后一个节点final Node l = last;// 创建一个新节点final Node newNode = new Node(l, e, null);// 使新的一个节点为最后一个节点last = newNode;// 如果最后一个节点为null，则表示链表为空，则将newNode赋值给first节点if (l == null)first = newNode;else//
源码分析——LinkedList源码分析
最新发布
帆的博客
08-08 133
LinkedList是一个实现了List接口和Deque接口的双端链表。LinkedList底层的链表结构使它支持高效的插入和删除操作，另外它实现了Deque接口，使得LinkedList类也具有队列的特性;LinkedList不是线程安全的，如果想使LinkedList变成线程安全的，可以调用静态类Collections类中的。
【java基础】LinkedList源码解析
秃头披风侠的博客
03-11 819
在java中，LinkedList就是使用双向链表存储元素，既然是链表，那么也就知道了该数据结构擅长添加和删除。对于需要频繁添加和删除的，我们应该使用LinkedList而表示ArrayList在开始介绍LinkedList之前，我们先来看一下该类的属性/**= null)/**= null)这三个属性就分别表示集合元素个数，头节点，尾节点。然后需要查看的就是类图，这是必不可少的！！！对于上面的类图，大家自行查看即可。
LinkedList的底层源码
huyulong0612的博客
04-18 326
1. 回顾 1. 集合: 理解为容器--它的长度可以变大的,而且它存储的都是对象类型。 2. List:----->它是一个接口，该集合中的元素可以重复，而且是有序的(有下标)。 ArrayList--->它的底层是数组结构，它的查询效率高，但是它的添加和删除效率低--因为它要牵涉到数据的迁移。 常见方法: add();size();indexOf(); contains(); get();remove();isEmpty(); LinkedList-...
LinkedList源码解析（JDK8）
知识记录
11-01 7507
在分析源码之前，前提是我们应该掌握链表这一块的知识，如果掌握了，那就来看看LinkedList的源码小世界吧！
第三章 LinkedList源码解析1
08-04
LinkedList源码解析 LinkedList是Java中的一种链表实现，它的底层是一个环形双向链表。在 LinkedList 中，节点之间通过引用相互连接，形成一个链表结构。LinkedList 提供了多种方法来操作链表，包括添加、删除、...
Java源码解析LinkedList
08-26
Java源码解析LinkedList Java源码解析LinkedList是Java集合框架中的一种重要数据结构。它是一种双向链表，具有高效的插入和删除操作。今天，我们将深入探讨LinkedList的源码，了解它的内部实现机制。 首先，让我们...
Java基于JDK 1.8的LinkedList源码详析
08-26
"Java基于JDK 1.8的LinkedList源码详析" LinkedList是Java中一个非常重要的数据结构，基于双向链表实现，适用于增删频繁且查询不频繁的场景。今天我们将深入分析LinkedList的源码，了解其内部实现机制和特点。 1. ...
Java集合系列之LinkedList源码分析
08-27
Java集合系列之LinkedList源码分析 概述： 本文详细介绍了Java集合系列之LinkedList的源码分析，主要介绍了LinkedList的底层实现、成员变量、构造器、增删改查方法等。LinkedList是一种基于双向链表的数据结构，...
LinkedList 部分源码
10-24
LinkedList的部分源码解析 包括部分常用的方法: add() ,remove(),get(),set()
LinkedList源码分析_016.pdf
09-13
《LinkedList源码解析》 LinkedList是Java集合框架中的一员，它是AbstractSequentialList的子类，同时也实现了List、Deque和Cloneable、Serializable接口。LinkedList作为双向链表，支持快速的添加、删除元素，尤其...
Jdk1.6 Collections Framework源码解析(2)-LinkedList
04-22
NULL 博文链接：https://brokendreams.iteye.com/blog/1916061
源码解析jdk7.0集合：LinkedList的底层实现原理.pdf
03-11
源码解析jdk7.0集合：LinkedList的底层实现原理.pdf
java——ArrayList-源码解析.docx
05-09
ArrayList是list接口下一个底层用数组实现的典型list类，也就是传说中的动态数组，用MSDN的说法就是array的复杂版本，它提供了动态的增加和减少元素...相对于LinkedList来说，ArrayList的特点是查询数据快，增删数据慢
集合类底层源码解析汇总
01-13
java所有集合类底层源码解析汇总，包括ArrayList、HashMap、HashSet、LinkedList、TreeMap、HashSet、ConcurrentHashMap等集合框架的底层实现源码大白话解读。
java多线程（十）使用线程安全的集合
热门推荐
xingjiarong的专栏
08-29 3万+
在多线程中，如果要并发的修改一个数据结构，那么很有可能会破坏这个数据结构。例如，一个线程可能要向一个散列表中插入一个元素，假如在调整各个桶之间的链接关系时被剥夺了控制权，而此时正好有另外一个线程正在遍历链表，则可能会产生异常或者死循环。 可以通过锁来保护共享的数据结构，但是选择线程安全的实现作为替代可能更容易一些。 一、旧的线程安全的集合 任何集合类都可以通过使用同步包装器变成线程安全的：
LinkedList 源码分析
Mr_zhao
05-31 186
本节我们来学习一下LinkedList，LinkedList相对ArrayList而言其使用频率并不是很高，因为其访问元素的性能相对于ArrayList而言比较慢，至于原因我们下面讲开始讲解，本节重点是了解其内部的结构，会简单实现一个简单的LinkedList 即可。 一、LinkedList的简单使用 任何代码在深入分析前，首先需要会使用，因此我们先看下基本的使用列子: public c...
LinkedList源码超详细解析
eternal_yy
10-26 253
文章目录LinkedList源码分析1. 整体架构1. 类定义2. 底层结构3. 常用方法源码解析1. 构造方法2. 新增操作1. add（）方法（尾插）2. addFirst（）方法 （头插）3. 删除操作1. remove（）方法 （也就是removeFirst方法）2. removeLast（）方法3. remove（int index）方法（指定下标删除节点）⭐4. 节点查询1. get（...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值