LinkedList接口源码解读

已于 2024-08-03 19:39:29 修改
阅读量470 收藏 21
点赞数 14
分类专栏： 源码解析 文章标签： java 链表 算法 后端 开源
于 2024-08-03 16:46:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63944437/article/details/140892752
版权

LinkedList 接口源码解读（一）

前言

因为追求质量，所以写的较慢。大概在接下来的三天内会把LinkedList源码解析出完。大概还有两篇文章。废话不多说，正片开始！

大家都知道，LinkedList是在Java底层中是由 双向链表 实现的。那么今天我们就来阅读下源码，看看Java是如何实现这个功能强大的集合。

注意： JDK1.6 之前为双向循环链表，JDK1.7 取消了循环，只使用了双向链表。

首先，我们看一下LinkedList类定义

public class LinkedList<E> 
    extends AbstractSequentialList<E> 
    implements List<E>, Deque<E>, Cloneable, Serializable {
    // transient 关键字表示被该关键字修饰的属性不会被序列化。
    transient int size;
    transient Node<E> first;
    transient Node<E> last;
    private static final long serialVersionUID = 876323262645176354L;
}

一. 继承和实现关系

LinkedList 类继承了 AbstractSequentialList ，而AbstractSequentialList 又继承了 AbstractList 。

  • 我们知道 ArrayList也继承了AbstractList ，所以LinkedList中的大部分方法会和ArrayList相似。

LinkedList类实现了List、Deque 、Cloneable、Serializable 接口。

  • List ： **表明它是一个列表，支持添加、删除、查找等操作，并且可以通过下标进行访问。 **

  • Deque ： 继承自 Queue 接口，具有双端队列的特性，支持从两端插入和删除元素，方便实现栈和队列等数据结构。

  • Cloneable ：Cloneable 注解是一个标记接口，我们点进去会发现它并没有任何方法。此接口表明LinkedList具有拷贝能力，可以进行深拷贝或浅拷贝操作 。

    package java.lang;

public interface Cloneable {
}

  • Serializable : 表明它可以进行序列化操作，也就是可以将对象转换为字节流进行持久化存储或网络传输，非常方便。
    在这里插入图片描述

二、属性实现

LinkedList 中的元素属性是通过 Node 类来声明的：

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

三、初始化

在进入正题之前，我先来给各位科普下 transient 关键字的作用是什么？

相信大家在阅读源码的过程中，很多属性的定义前都会加transient关键字。

  • transient是Java语言的关键字，用来表示一个成员变量不是该对象序列化的一部分。当一个对象被序列化的时候，transient所修饰的变量的值不包括在序列化的结果中。
transient int size;  // 链表节点的个数，默认为 0
transient Node<E> first;  // 指向链表的第一个节点
transient Node<E> last;  // 指向链表的最后一个节点
private static final long serialVersionUID = 876323262645176354L;

// 无参构造方法，调用此构造方法创建的集合长度默认为 0
public LinkedList() {
    this.size = 0;
}

// 有参构造方法，传入一个集合类型作为参数，会创建一个与传入集合相同元素的链表对象
public LinkedList(Collection<? extends E> c) {
    this();
    this.addAll(c);
}

在调用有参构造方法时，LinkedList会调用两个方法this()、addAll()。

  • this()：调用有参构造的时候，首先会去调用无参构造，创建一个默认大小为 0 的集合。

  • addAll()：底层就是将传过来的集合类型转换成 Object[]数组，然后依次遍历数组中的每个元素，添加到链表上。

源码：

// 将集合类型保存到链表中
public boolean addAll(Collection<? extends E> c) {
    // 底层调用了重载后的 addAll(int index, Collection<? extends E> c)  
    return this.addAll(this.size, c);  // 等同于 return this.addAll(0, c);
}

// addAll() 最终实现类
public boolean addAll(int index, Collection<? extends E> c) {
    	// 索引越界检查，条件为：index >= 0 && index <= this.size
    	// 满足条件返回true，否则报错
        this.checkPositionIndex(index);
        Object[] a = c.toArray();  // 转换成 Object[]
        int numNew = a.length;
    	// 非空校验
        if (numNew == 0) {
            return false;
        } else {
            // 核心逻辑！！
            // pred 可以理解为记录节点位置的指针。每有一个新节点就会更新 pred 的值
            // succ 是一个标记节点，循环结束后会判断当前 succ 是否为 null
            Node pred;  
            Node succ;
            if (index == this.size) {  
                // 调用有参构造方法时，size = 0 并且 index = 0，所以会进入下方的逻辑
                succ = null;
                pred = this.last;  // 此时，链表为空，所以 last = null。可以转换成 pred = null
            } else {
                succ = this.node(index);
                pred = succ.prev;
            }

            Object[] var7 = a;
            int var8 = a.length;
			// 循环数组，依次往链表中添加元素
            for(int var9 = 0; var9 < var8; ++var9) {
                Object o = var7[var9];  // 取出指定索引的值
                E e = o;
                // LinkedList 底层是由双向链表实现的
                // 此语句的意思为：创建一个前缀指针指向 pred，值为 e，后缀指针指向 null 的新节点
                Node<E> newNode = new Node(pred, e, (Node)null);
                if (pred == null) {  // 第一次循环时 pred 肯定为 null，进入下方逻辑
                    // 表明当前 newNode 是链表的第一个节点
                    // 设置 LinkedList 的 first 指针指向此新节点
                    this.first = newNode;  
                } else {  // 除了第一次进入循环，后面的每次循环都会进下方逻辑
                    // 依次往链表中添加元素 1 -> 2 -> 3
                    pred.next = newNode;
                }
				// 更新 pred 的值
                pred = newNode;
            }

            if (succ == null) {
                // 此时的 pred 节点是当前链表的最后一个值
                // 设置 LinkedList 的 last 指针指向此循环结束后的最后一个 pred 节点
                this.last = pred;  
            } else {
                pred.next = succ;
                succ.prev = pred;
            }
			
            // 无关操作  更新链表中的节点数
            // size 是链表所用来记录当前节点值的
            // modCount 是 List 集合存储元素个数的值
            // 因为 LinkedList 继承了 AbstractSequentialList，所以 List 的操作它也都有
            this.size += numNew;
            ++this.modCount;
            return true;
        }
    }

四、插入元素

LinkedList 除了实现了 List 接口相关方法，还实现了 Deque 接口的很多方法，所以我们有很多种方式插入元素。

下面我将以 List 、Queue、Stack这三种数据结构分开带大家阅读源码。

可能会有朋友好奇，Stack是什么？Stack是栈这种数据结构，他的特点是只有一端能进出，这就导致栈的特点是先进后出，这和队列Queue的先进后出恰好相反

那朋友们又要好奇了，LinkedList在他的类方法定义上也没看到一个叫 Stack的接口啊，它怎么能当作栈呢？

大家要记住，数据结构底层都是相通的。栈有多种实现方式，可以通过单向链表实现栈、数组实现栈、双向链表实现栈，而 LinkedList正是通过双向链表来实现了对栈的操作

/**
 * 为了让大家能够明白上面那句话的意思，我用单向链表实现了一个栈，各位可以看看代码
 * @Description 单向链表实现栈
 * @Author Mr.Zhang
 * @Date 2024/8/2 14:40
 * @Version 1.0
 */
public class LinkedListStack<E> implements Iterable<E> {
    // 容量
    private int capacity;
    private int size;  // 栈中元素的个数
    // 头指针指向哨兵节点
    private Node<E> head = new Node<>(null, null);

    public LinkedListStack(int capacity) {
        this.capacity = capacity;
    }
	
    static class Node<E> {
        E value;
        Node<E> next;

        public Node(E value, Node<E> next) {
            this.value = value;
            this.next = next;
        }
    }

    /**
     * 向栈顶压入元素
     *
     * @param value 待压入值
     * @return 压入成功返回 true，否则返回 false
     */
    @Override
    public boolean push(E value) {
        if (isFull()) {
            return false;
        }
        head.next = new Node<E>(value, head.next);
        size++;
        return true;
    }

    /**
     * 从栈顶弹出元素
     *
     * @return 栈非空返回栈顶元素，栈为空返回 null
     */
    @Override
    public E pop() {
        if (isEmpty()) {
            return null;
        }
        E value = head.next.value;
        head.next = head.next.next;
        size--;
        return value;
    }

    /**
     * 返回栈顶元素，不弹出
     *
     * @return 栈非空返回栈顶元素，栈为空返回 null
     */
    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return head.next.value;
    }

    /**
     * 检查栈是否为空
     *
     * @return  空返回 true，否则返回 false
     */
    @Override
    public boolean isEmpty() {
        return head.next == null;
    }

    /**
     * 检查栈是否已满
     *
     * @return 满了返回 true，否则返回 false
     */
    @Override
    public boolean isFull() {
        return capacity == size;
    }

    /**
    * 方便我用 增强for循环 测试
    */
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            Node<E> p = head.next;

            @Override
            public boolean hasNext() {
                return p != null;
            }

            @Override
            public E next() {
                E value = p.value;
                p = p.next;
                return value;
            }
        };
    }
}
  • List
    • add(E e) ： 用于在 LinkedList 的尾部插入元素，即将新元素作为链表的最后一个元素，时间复杂度为 O(1)。
    • addAll(int index, Collection<? extends E> c)：用于通过给定的集合类型数据创建一个LinkedList。 (此源码已经在上面了，下方不重复解读)
    • add(int index, E element)：用于在指定位置插入元素。这种插入方式需要先移动到指定位置，再修改指定节点的指针完成插入/删除，因此需要移动平均 n/2 个元素，时间复杂度为 O(n)。

源码：

// 在 LinkedList 尾部添加元素
public boolean add(E e) {
    this.linkLast(e);
    return true;
}

// 向 LinkedList 尾部添加元素的底层实现方法
void linkLast(E e) {
    Node<E> l = this.last;  // 获取最后一个节点
    // 根据传入的 e 创建新节点，新节点的前一个指针指向之前链表的最后一个节点
    Node<E> newNode = new Node(l, e, (Node)null);  
    this.last = newNode;  // 更新新节点的值
    if (l == null) {  // 判断如果当前链表为空
        this.first = newNode;  // 则将 LinkedList 的 last 指针也指向这个新节点
    } else {
        l.next = newNode; // 更新 l 的 next 指向的节点
    }

    // 无关操作  更新链表中的节点数
    ++this.size;
    ++this.modCount;
}

// 根据指定的索引插入元素
public void add(int index, E element) {
    // 索引越界检查，条件为：index >= 0 && index <= this.size
    // 满足条件返回true，否则报错
    this.checkPositionIndex(index);
    if (index == this.size) {  // 如果传递过来的 index 正好等于数组长度，则证明是向链表最后添加元素
        this.linkLast(element);
    } else {
        // 核心代码
        this.linkBefore(element, this.node(index));  // this.node(index)：找到待插入索引目前存在的节点元素
    }
}

// 根据指定的索引插入元素的底层实现方法
void linkBefore(E e, Node<E> succ) {
    // 定义一个节点元素保存 succ 的 prev，也就是它的前一节点信息
    Node<E> pred = succ.prev;
    // 初始化节点，并指明前驱和后继节点
    Node<E> newNode = new Node<>(pred, e, succ);
    // 将 succ 节点前驱引用 prev 指向新节点
    succ.prev = newNode;
    // 判断前驱节点是否为空，为空表示 succ 是第一个节点
    if (pred == null) {
        this.first = newNode;  // 当前 newNode 节点就是新的首节点，所以要让 first 指向 newNode
    } else {
        pred.next = newNode;
    }
	// 无关操作  更新链表中的节点数
    ++this.size;
    ++this.modCount;
}
后端小张
关注
  • 14
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LinkedList源码解读—Java8版本
梵高
01-06 2244
LinkedList是Collection下的一个list实现，就像ArrayList一样。 和ArrayList不同的是它是链表结构，而ArrayList是顺序结构。
java LinkedList源码详解及实例
08-31
Java中的LinkedList是一个实现了List接口的双向链表数据结构。它提供了高效的插入和删除操作，但随机访问性能相对较差。LinkedList的实现方式使得它在需要频繁进行添加、删除操作且顺序访问较多的场景下表现优越。 ...
LinkedList源码解读
wangshuang1631的博客
10-27 1768
一、LinkedList概述： LinkedList与ArrayList一样，是实现了List接口。由于LinkedList是基于链表实现的，所以它执行插入和删除操作时比ArrayList更高效，而随机访问的性能要比ArrayList低。 二、LinkedList的实现： 1、构造方法//构造一个空的LinkedList public LinkedList() { } //接收一个Collec
Java LinkedList 源码解读
码农架构
08-20 194
总体介绍 LinkedList同时实现了List接口和Deque接口，也就是说它既可以看作一个顺序容器，又可以看作一个队列（Queue），同时又可以看作一个栈（Stack）。这样看来，LinkedList简直就是个全能冠军。当你需要使用栈或者队列时，可以考虑使用LinkedList，一方面是因为Java官方已经声明不建议使用Stack类，更遗憾的是，Java里根本没有一个叫做Queue的类（它是个接口名字）。关于栈或队列，现在的首选是ArrayDeque，它有着比LinkedList（当作栈或队列使用时）
List接口中的ArrayList与LinkedList源码解读
故常无，欲以观其妙；常有，欲以观其徼；
04-13 205
ArrayList与LinkedList
Java Review - LinkedList源码解读
热门推荐
小工匠
11-14 2万+
文章目录Pre概述 Pre Java Review - ArrayList 源码解读 概述 从上图可知: LinkedList同时实现了List接口和Deque接口，既可以看作一个顺序容器，又可以看作一个队列(Queue)，同时又可以看作一个栈(Stack) 。 当需要使用栈或者队列时，可以考虑使用LinkedList，一方面是因为Java官方已经声明不建议使用Stack类，更遗憾的是，Java里根本没有一个叫做Queue的类(它是个接口名字)。 关于栈或队列，现在的首选是ArrayDeque
Java集合框架源码解读——Collection - LinkedList源码解析
在路上
04-06 436
LinkedList同时实现了List接口和Deque接口，也就是说它既可以看作一个顺序容器，又可以看作一个队列(Queue)，同时又可以看作一个栈(Stack)。当你需要使用栈或者队列时，可以考虑使用LinkedList，一方面是因为Java官方已经声明不建议使用Stack类，更遗憾的是，Java里根本没有一个叫做Queue的类(它是个接口名字)。关于栈或队列，现在的首选是ArrayDeque，它有着比LinkedList(当作栈或队列使用时)有着更好的性能。
LinkedList源码解析
qq_32073629的博客
08-07 756
深入理解LinkedList源码
java linkedlist源码_java LinkedList源码分析
weixin_39906192的博客
02-13 110
首先介绍一下java集合，集合接口Collection，子接口List，Set，Queue。LinkedList就是子结构List的一个现实。并且它实现了其他接口，如Deque-double ended queue双向队列，还有Cloneable, java.io.Serializable可克隆和可序列化结构，以及List下的子接口AbstractSequentialList顺序获取结构。Link...
java源码解读之LinkedList
linxiaorui的博客
04-05 219
package java.util; import java.util.function.Consumer; /** * 通过LinkedList的继承和实现的类与接口,可以看出: * 由于继承了AbstractSequentialList的双向链表,因此可以被当作堆栈、队列或双端队列进行操作 * 实现 List 接口,能对它进行队列操作 * 实现 Deque 接口,即能将Linked...
java源码解读-JavaSource:Java源码解读
05-19
在Java编程语言的世界里，源码解读是提升技术深度、理解内部机制的关键步骤。"JavaSource:Java源码解读"项目旨在帮助开发者深入探索Java的内部工作原理，从而更好地运用和优化代码。在这个项目中，我们可以看到一...
java源码解读-JavaAPI:jdk源码解读分析
05-19
本篇文章将对Java API的部分关键组件进行源码解读，帮助读者深入理解其工作原理。 1. **对象创建与内存管理**： - `Object`类：所有Java类的基类，包含了如`clone()`, `equals()`, `hashCode()`等方法。理解`...
ArrayList源码分析
05-05
ArrayList是Java集合框架中的一员，它是List接口的一个实现，提供了动态数组的功能。ArrayList的主要特点是它在内存中以数组的形式存储元素，因此对于随机访问元素，它的性能非常高效。本篇文章将深入探讨ArrayList...
java源码解读-ITG-JavaBook01:Java面试高频源码解读
05-19
《Java源码解读-ITG-JavaBook01: Java面试高频源码解读》是一部针对Java程序员面试准备的深入学习资料。在这个项目中，我们将会探索Java语言的一些核心概念和常用库的源代码，帮助开发者更好地理解Java的内部机制，...
J031_使用TCP协议支持与多个客户端同时通信
最新发布
lzn20161229的博客
08-03 183
使用TCP协议支持与多个客户端同时通信。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 527
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 520
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 563
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值