LinkedList 源码分析

于 2022-09-04 15:50:26 发布
阅读量505 收藏
点赞数
分类专栏： # Collections 文章标签： java 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44029159/article/details/126669828
版权

1. 前言

LinkedList 解析本文将分为如下几部分：

  1. 类结构
  2. 存储结构
  3. 常用方法及执行效率
  4. 线程安全
  5. ArrayList 优缺点
  6. 使用场景

注：本文大部分分析都围绕着源码，源码基于 JDK 1.8。


2. 类结构

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable {}

AbstractSequentialList：其内部的代码是用于减少重复性。相较于 AbstractList，此抽象类适用于没有随机访问性的 List。
List：List 的标准规范。
Deque：此接口继承自 Queue，在其基础上扩展了双端队列的标准。
Cloneable：赋予了 LinkedList 对象拷贝功能
Serializable：赋予 LinkedList 序列化功能。


2. 存储结构

public class LinkedLise {
	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;
        }
    }
}

first，last两个属性是用于存储数据，其类型为 Node。

Node 的结构也很直白，大致如下图：
在这里插入图片描述

注意：

  • 当Node作为根节点时，Node的 prev 为 null，因为根节点无前驱节点！
  • 当Node作为尾节点时，Node的 next 为 null，因为尾节点无后继节点！

3. 常用方法及执行效率

3.1 无参构造

public LinkedList() {}

emm，啥也没有。。。无意水了一下🌚


3.2 add()

public boolean add(E e) {
	// 见下文 3.2.1
    linkLast(e);
    return true;
}

3.2.1 linkLast()

void linkLast(E e) {
	// 此行代码无实际意义
    final Node<E> l = last;
    
    /*
		新建节点，调用 Node 类型的全参构造。
		Node(Node<E> prev, E element, Node<E> next)
		new Node<>(l, e, null)，将 last 作为新节点的前驱节点，e 是数据，后继节点为 null 前文已经介绍过了，此处不再叙述。
     */
    final Node<E> newNode = new Node<>(l, e, null);
    
    // 将 last 属性更新为新增节点（newNode）
    last = newNode;
    
    /*
    	需要注意的是，当 last 为 null 时，此时 last 中是一个节点都没有的。
    	也就直接证明了该节点为第一个节点，也是 LinkedList 根（root）节点。
    	反之，当 last 中存在节点时，将新增节点作为后继节点插入。
     */
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    
    // LinkedList 的元素个数 + 1
    size++;
    
    /*
		该变量主要是用于记录结构变化的次数（添加数据，删除数据，调整数组大小等）。
		其该变量作用体现在迭代时，比较前后的 modCount 是否变化。
		如果 modeCount 前后不一致，则抛出ConcurrentModificationException（并发修改异常）！
     */
    modCount++;
}

3.3 remove()

public boolean remove(Object o) {
	// 如果入参 o 为空，那么将会删除该 LinkedList 第一个为 null 的元素
    if (o == null) {
    	// 遍历所有元素
        for (Node<E> x = first; x != null; x = x.next) {
        	// 如果该元素等于 null，则 if 语句条件成立，执行 if 代码块
            if (x.item == null) {
            	// 详见下文 3.2.1 unlink() 解析
                unlink(x);
                return true;
            }
        }
    } else {
    	// 遍历所有元素
        for (Node<E> x = first; x != null; x = x.next) {
        	// 使用 equals 判断两者相等性，如果相等则删除
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

时间复杂度 O(n)


3.2.1 unlink();

E unlink(Node<E> x) {
	// 取出被删除节点的值
    final E element = x.item;
    // 被删除节点的下一个元素
    final Node<E> next = x.next;
    // 被删除节点的上一个元素
    final Node<E> prev = x.prev;

	// 因为根节点没有前驱，所以当删除的节点为根节点时，if 语句成立，执行代码块
	// 反之，删除的不是根（首）节点
    if (prev == null) {
    	// 更新根（首）节点，将根节点替换为删除元素的下一个元素
        first = next;
    } else {
    	// x.prev.next 改变引用（不再指向被删除元素）
        prev.next = next;
        // 将元素指向置空
        x.prev = null;
    }

	// 如果删除的是尾节点，则尾节点没有后继，if 条件成立，执行 if 代码块
	// 反之，删除的不是尾节点
    if (next == null) {
    	// 更新尾节点，将尾节点替换为删除元素的上一个元素
        last = prev;
    } else {
	    // x.next.prev 改变引用（不再指向被删除元素）
        next.prev = prev;
        // 将元素指向置空
        x.next = null;
    }

	// 将元素值置空
    x.item = null;
    
    // LinkedList 元素个数 - 1
    size--;
    
    // 上文讲过，可以去看看
    modCount++;
    
    // 返回元素值
    return element;
}

3.4 set()

public E set(int index, E element) {
	// 详见下文 3.4.1 checkElementIndex()
    checkElementIndex(index);
    
    // 详见下文 3.4.2 node()
    Node<E> x = node(index);
	
	// 取出旧值保存，用作返回值
    E oldVal = x.item;
    
    // 替换节点值
    x.item = element;
    
    return oldVal;
}

3.4.1 checkElementIndex()

private void checkElementIndex(int index) {
	// 如果给定索引无效，则抛出索引越界异常
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
3.4.1.1 isElementIndex()
private boolean isElementIndex(int index) {
	// 判断给定索引是否有效
    return index >= 0 && index < size;
}

3.4.2 node()

// 获取指定节点（元素）
Node<E> node(int index) {
	// 采用了对半查找
	// 如果 index 小于长度的一半（size >> 1），那么 if 条件成立，执行 if 代码块
	// 反之
    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;
    }
}

3.5 get()

public E get(int index) {
	// 详见 3.4.1 checkElementIndex()
    checkElementIndex(index);
    
	// 详见 3.4.2 node()
    return node(index).item;
}

3.5 indexOf()

简单明了，此方法不解析

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

3.6 其它方法

由于 LinkedList 实现了 Deque 接口，所以 LinkedList 支持双端队列操作。
具体的操作方法可以查阅 LinkedList 源码。


4. 线程安全

在上述方法中，并没有见到如 synchronized，ReentrantLock 等来维护线程安全的操作，也就直接证明了该方法是非线程安全的。


5. LinkedList 优缺点

优点：

  • 适用于高效的增删操作
  • 因实现了双端队列，具有更高灵活性

缺点：

  • 因为存储结构影响，获取指定元素的时间复杂度为O(n)
  • 没有随机访问特性

6. 使用场景

  1. 需要经常增删
  2. 元素访问不频繁
  3. 对元素顺序有要求
  4. 有双端队列特性的需求

至此，文章到此就结束了。
博主水平有限，博文有错误的地方可以私信或评论指出。
Bye.

l8y11
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入剖析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双向链表源码分析（附详细图解！！）
最新发布
A_diligent_man的博客
07-18 383
本文章分析LinkedList源码。
LinkedList源码解析
qq_32073629的博客
08-07 750
深入理解LinkedList源码
LinkedList 跑出的ConcurrentModificationException异常
smithdoudou88的专栏
08-31 3237
LinkedList后台抛出了ConcurrentModificationException异常
LinkedList源码分析
12-09
LinkedList源码分析，java作业，主要是对rar包中的LinkedList分析
Java LinkedList源码分析
01-20
简介 　LinkedList 是一个常用的集合类，用于顺序存储元素。 LinkedList 经常和 ArrayList 一起被提及。...本文分析 LinkedList 的具体实现。 　继承关系 　public class LinkedList 　extends AbstractS
Java集合系列之LinkedList源码分析
08-27
Java集合系列之LinkedList源码分析 概述： 本文详细介绍了Java集合系列之LinkedList的源码分析，主要介绍了LinkedList的底层实现、成员变量、构造器、增删改查方法等。LinkedList是一种基于双向链表的数据结构，...
Java 集合之LinkedList源码分析
01-20
LinkedList是通过节点的连接实现链表的数据结构，向linkedList中插入或删除元素的速度是特别快，而随机访问的速度相对较慢，这个是由于链表本身的性质造成的，在链表中，每个节点都包含了前一个节点的引用，后一个...
LinkedList源码分析_016.pdf
09-13
《LinkedList源码解析》 LinkedList是Java集合框架中的一员，它是AbstractSequentialList的子类，同时也实现了List、Deque和Cloneable、Serializable接口。LinkedList作为双向链表，支持快速的添加、删除元素，尤其...
Java进阶之----LinkedList源码分析
Zhengw博客专栏
04-12 9364
今天在看LinkedList的源代码的时候，遇到了一个坑。我研究源码时，发现LinkedList是一个直线型的链表结构，但是我在baidu搜索资料的时候，关于这部分的源码解析，全部都说LinkedList是一个环形链表结构。。我纠结了好长时间，还以为我理解错了，最后还是在Google搜到了结果：因为我看的源码是1.7的而baidu出来的几乎全部都是1.6的。而且也没有对应的说明。在1.7之后，or
LinkedList 源码解析
u011035026的博客
11-07 663
利用栈判断是否有效括号问题 前面三天文章咱们讨论了： 基于数组的二次封装添加链接描述 自定义栈和队列 自定义循环队列 有兴趣的同学可以去看看上面的文章，这章咱们来利用栈的知识点来分析“有效括号”这个算法题。 题目： 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足：左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。注意...
java基础-Java集合框架-Collection子接口-LinkedList的源码分析
J三石的博客
04-22 90
Java集合框架-Collection子接口之一-List接口-LinkedList源码分析 LinkedList类： public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable { transient int size = 0; /**
LinkedList原码分析（基于JDK1.6）
weixin_33920401的博客
12-25 192
    《Java集合类》一文中已经最List的基本操作进行说明，并且比较了ArrayList和LinkedList的效率。本文将进一步解析LinkedList。     LinkedList也和ArrayList一样实现了List接口，但是它执行插入和删除操作时比ArrayList更加高效，因为它是基于链表的。基于链表也决定了它在随机访问方面要比ArrayList逊色一点。     除此之外...
LinkedList源码解析（基于JDK1.8）
m0_37884977的博客
05-27 8384
LinkedList将做为双链表来实现，它本身实现了List接口和Deque接口，并且实现了所有可选的列表操作，并且允许包含所有元素（包括null）。 下图是LinkedList的UML图： 从图中我们可以看出： 继承了AbstractSequentialList抽象类：在遍历LinkedList的时候，官方更推荐使用顺序访问，也就是使用我们的迭代器。（因为LinkedList...
LinkedList的源码解析（含详细注释）
SIESTA030的博客
01-24 378
1、今日阅读部分 1.1 三个基本参数以及一个重要的节点内部类 size 属性代表了 LinkedList 目前链表中元素的个数。 头尾指针就是为了辨别链表哪是头哪是尾。 这里用到了 transient 关键字，之前一直没用过这个关键字，查阅文档之后才知道被该关键字修饰的成员变量在保存对象时，该属性并不会被保存，也就是不能被序列化。 // 被改关键字标注的属性不可被序列化 // 代表了 LinkedList 对象目前元素的个数。 transient int size = 0;
linkedlist源码分析
04-27
以下是LinkedList的源码分析： 1. 声明LinkedList类 ```java public class LinkedList<E> extends AbstractSequentialList implements List, Deque, Cloneable, java.io.Serializable { transient int size = 0;...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值