LinkedList源码理解

最新推荐文章于 2025-04-17 08:27:03 发布
最新推荐文章于 2025-04-17 08:27:03 发布
阅读量3k 收藏 12
点赞数 3
分类专栏： 源码理解 文章标签： 源码 数据结构 linkedlist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_26411333/article/details/51585222
版权
本文深入解析LinkedList的源码，揭示其作为链表数据结构的特点和优势。LinkedList在添加和移除数据方面效率较高，但查询效率较低。文章详细分析了成员变量、构造方法、add()、get()、remove()和IndexOf()等关键操作，为读者提供使用LinkedList的指导建议。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

LinkedList源码理解

导语

与ArrayList源码理解放在一起查阅，效果更好

本文先给出LinkedList的特点，再从源码的角度分析为什么会有这些特点：

  1. 对成员变量的分析，可以知道LinkedList的数据结构是链表
  2. 对add()方法的分析，可以得知LinkedList添加数据的效率高
  3. 对get()方法的分析，可以看出LinkdedList查询的效率不高
  4. 对remove()方法的分析，可以了解到LinkedList删除数据的效率高

特点

相对于ArrayList，LinkedList有以下特点：

  1. 添加和移除数据效率高
  2. 查询的效率不高
  3. 数据结构是双链表

源码分析

成员变量

LinkedList的结构是一个双链表，如果能拿到链表的头部或者尾部，就可以对整个链表进行相应的操作

//容器的大小
transient int size = 0;

//头结点
transient Node<E> first;

//末尾节点
transient Node<E> last;

//节点类，双向的
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既保存了头结点，有保存了末尾节点，又因为是双链表，那么

  1. 可以从first开始，进行遍历操作
  2. 可以从last往前，进行遍历操作

构造方法

//构造方法
public LinkedList() {
}

public LinkedList(Collection<? extends E> c) {
    this();
    //将集合转换成链表
    addAll(c);
}

所对应的方法

//将集合转换成链表
public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}


//将集合转换成链表，添加到指定的位置
public boolean addAll(int index, Collection<? extends E> c) {
    //校验非法参数
    checkPositionIndex(index);

    //将集合转成数组
    Object[] a = c.toArray();
    //获取长度
    int numNew = a.length;
    //如果c为空，不进行操作
    if (numNew == 0)
        return false;

    //pred：要添加位置的前一个节点
    //succ：要添加位置的节点
    Node<E> pred, succ;

    //判断是否添加到末尾
    if (index == size) {
        //添加到末尾，此时：pred为last,succ为null

        succ = null;
        pred = last;
    } else {
        //添加到指定的位置

        //获取index所对应的节点
        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，下次循环使用
        pred = newNode;
    }

    //判断是否是添加到末尾
    if (succ == null) {
        //是添加到末尾，那么：
        //集合转换成链表的最后一个节点就是末尾节点，所以要更新末尾节点的对象
        last = pred;
    } else {
        //不是添加到末尾

        //集合转换成链表的操作中，（也就是for循环）
        //没有对链表的末尾节点建立连接
        //这里把之前链表的剩余部分建立连接
        pred.next = succ;
        succ.prev = pred;
    }

    //更新size
    size += numNew;
    //更新modCount
    modCount++;
    return true;
}

说明：

  1. 不传参数的构造方法中，没有任何操作，此时链表为空，first,last也为空
  2. 传入集合的构造方法，将集合转换成链表

add()的分析

add(E e)

//将数据添加到链表的末尾
public boolean add(E e) {
    //添加到链表的末尾
    linkLast(e);
    return true;
}

//将数据添加到链表的末尾
void linkLast(E e) {
    //获取当前的末尾节点
    final Node<E> l = last;
    //将数据封装成节点,该节点向前建立连接
    final Node<E> newNode = new Node<>(l, e, null);

    //更新last为新封装的节点
    last = newNode;

    //链表为空时的处理
    if (l == null)
        //first也是新添加的节点，此时first=last
        first = newNode;
    //一般情况下的处理
    else
        //之前的末尾节点向后建立连接
        l.next = newNode;

    //更新size
    size++;
    //更新modCount
    modCount++;
}

说明：直接向链表的末尾添加一个节点，并不会对原来的结构进行修改，与ArrayList相比，不会出现遍历复制的情况，所以：效率要高

add(int index, E element)

//添加数据到指定的位置
public void add(int index, E element) {
    //非法参数校验
    checkPositionIndex(index);

    //判断是否添加到末尾
    if (index == size)
        //添加到链表的末尾
        linkLast(element);
    else
        //添加到指定的位置
        linkBefore(element, node(index));
}

//获取指定位置上的节点
Node<E> node(int index) {
    // 1.判断index是靠近头部还是靠近末尾
    // 2.靠近头部，从头节点向后遍历比对
    // 3.靠近末尾，从末尾节点向前遍历比对

    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) {
    // 获取前一个节点
    final Node<E> pred = succ.prev;
    // 封装成节点，并与succ建立向后的连接，与pred建立向前的连接
    final Node<E> newNode = new Node<>(pred, e, succ);

    //succ建立向前的连接
    succ.prev = newNode;

    //添加到头部的处理
    if (pred == null)
        //更新first
        first = newNode;
    //一帮情况下，建立pred向后连接
    else
        pred.next = newNode;

    //更新数据
    size++;
    modCount++;
}

说明：这里的耗时操作是找出相应的节点。

  1. 一般情况下，与ArrayList的add(int index,E e)相比，效率还是高
  2. 最坏情况下，效率就没有明显的优势

get()的分析

//找出指定位置的数据
public E get(int index) {
    //非法参数校验
    checkElementIndex(index);
    //返回相应的数据，node()方法在上面查找
    return node(index).item;
}

说明：这里查找相应的数据，是要遍历链表，与ArrayList中的直接锁定内存相比，效率是要低很多

remove()的分析

remove(int index)

//移除指定位置上的数据
public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

//断开指定节点与链表的连接
E unlink(Node<E> x) {
    // 获取当前节点的数据
    final E element = x.item;
    // 前一个节点
    final Node<E> next = x.next;
    // 后一个节点
    final Node<E> prev = x.prev;

    //判断是否是头结点
    if (prev == null) {
        // 头结点的处理
        // 更新first为下一个节点
        first = next;
    } else {
        //一般情况下的处理

        //前一个节点与后一个节点建立向后的连接
        prev.next = next;
        //断开向前的连接，断开了一半的连接
        x.prev = null;
    }

    //判断是否是末尾节点
    if (next == null) {
        //末尾节点的处理
        //更新last为前一个节点
        last = prev;
    } else {
        //一般情况下的处理

        //后一个节点与前一个节点建立向前的连接
        next.prev = prev;
        //断开向后的连接，断开了全部连接
        x.next = null;
    }

    //置空，方便GC
    x.item = null;

    //更新数据
    size--;
    modCount++;
    return element;
}

说明：与ArrayList相比，LinkedList的remove(int index)效率要高很多

remove(Object o)

//移除指定的数据
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;
}

说明：这里的耗时操作是找出相应的节点。效率还是要比ArrayList要高

IndexOf()的分析

//找出o第一次出现的位置
public int indexOf(Object o) {
    //逻辑很简单：遍历比较，找出相应的位置

    int index = 0;
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    return -1;
}

说明：这里的代码与ArrayList的基本一致：都是遍历比对，找出相应的位置。因为LinkedList的数据结构没有锁定内存，效率要低一些

结语

这里给出的使用建议：如果集合的增删操作较多，使用LinkedList

建议与ArrayList源码分析一起阅读
转载请标明出处：http://blog.youkuaiyun.com/qq_26411333/article/details/51585222

JavaSE基础知识(二十一)--Java集合(容器)之类LinkedList的源码分析(已修改)
ruidianbaihuo的博客
12-31 456
Java SE 是什么，包括哪些内容(二十一)？ 本文内容参考自Java8标准 顺序访问列表的一个常用实现类： LinkedList 类声明： public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Clonea...
Java中LinkedList源码深度解析
u011403205的博客
02-12 438
LinkedList是Java集合框架中一个基于双向链表实现的高效集合类。通过源码分析，我们了解了其数据结构、核心方法以及性能特点。在实际开发中，根据具体需求选择合适的集合类可以显著提升程序的性能。希望这篇文章能帮助您更好地理解LinkedList的源码实现！如果您有更多问题，欢迎随时提问。
LinkedList源码解析
网易数帆社区博客
12-26 146
此文已由作者赵计刚授权网易云社区发布。欢迎访问网易云社区，了解更多网易技术产品运营经验。一、对于LinkedList需要掌握的八点内容LinkedList的创建：即构造器往LinkedList中添加对象：即add(E)方法获取LinkedList中的单个对象：即get(int index)方法修改LinkedList中的指定索引的节点的数据set(int index, E element)删除Li...
JDK集合源码之LinkedList解析
最新发布
兴趣使然的草帽路飞
04-17 3627
声明：尊重他人劳动成果，转载请附带原文链接！ 1.LinkedList继承体系 LinkedList：LinkedList是一个以双向链表实现的List，它除了作为List使用，还可以作为队列或者栈来使用。 从继承体系可以看出，LinkedList实现了Cloneable和Serializable接口，说明其可以被克隆，也可以被序列化！同样的，LinkedList被克隆的时候，和ArrayList一样二者均是浅拷贝。 对于如何实现集合的浅拷贝和序列化，我在上一篇文章JDK集合源码之ArrayList解.
LinkedList源码分析
axrda71687的博客
09-10 172
LinkedList简介 LinkedList类继承关系如下： public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable 从上面Link...
Java集合系列之LinkedList源码分析
08-27
Java集合系列之LinkedList源码分析 概述： 本文详细介绍了Java集合系列之LinkedList的源码分析，主要介绍了LinkedList的底层实现、成员变量、构造器、增删改查方法等。LinkedList是一种基于双向链表的数据结构，...
第三章 LinkedList源码解析1
08-04
LinkedList源码解析 LinkedList是Java中的一种链表实现，它的底层是一个环形双向链表。在 LinkedList 中，节点之间通过引用相互连接，形成一个链表结构。LinkedList 提供了多种方法来操作链表，包括添加、删除、...
LinkedList源码学习分析
03-30
《LinkedList源码学习分析》 LinkedList作为Java集合框架中的一员，是基于链表数据结构实现的线程不安全容器。本文将深入探讨LinkedList的实现原理、核心方法的代码实现，并对比ArrayList，理解其特性和使用场景。 ...
LinkedList源码详解
小白
02-28 356
LinkList概述 LinkedList 是 List 接口链表的实现。基于双向链表实现的方式使得 LinkedList 在插入和删除时更优于 ArrayList，而随机访问则比 ArrayList 逊色些。 但也是线程不安全 LinkList UML类图 LinkList构造方法 //构造一个空列表 public LinkedList() { ...
客户端API-文档对象模型DOM
qq_30906791的博客
12-16 205
什么是文档对象模型 个人学习笔记仅供参考，详细内容请参考MDN——原文链接. 像您这样的开发人员可以在页面已经渲染之后使用JavaScript操作DOM从而修改HTML文档页面。 您可以在此处看到文档中的每个元素和文本位在树中都有其自己的条目-每个元素都称为一个节点。 您还将遇到用于描述节点类型以及它们在树中相对于彼此位置的各种术语： 元素节点：元素，存在于DOM中。 根节点：树中的顶部节点，对于HTML来说，它始终是HTML节点 子节点：直接在另一个节点内部的一个节点。 例如，在上面的示例中，IMG是
LinkedList源码
我的博客
06-07 581
ListItr类定义在LinkedList的内部，每个ListItr对象隐式持有LinkedList对象的引用，该迭代器在遍历时对ListItr对象添加、删除、修改元素，都会影响到LinkedList对象。LinkedList 的底层数据结构为双向链表，每个节点包含两个引用，prev指向当前节点前一个节点，next指向当前节点后一个节点，可以从头结点遍历到尾结点，也可以从尾结点遍历到头结点。对集合使用迭代器遍历时，可以使用迭代器内部的remove()或add()方法对集合中元素进行增删操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值