LinkedList源码解析

于 2022-02-23 09:12:54 发布
阅读量756 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40205116/article/details/110939703
版权

LinkedList集合底层是通过双向链表实现的。它实现了List接口和Deque接口，所以它是一个双端队列的集合。

文章目录

双向链表

如果对链表不熟悉的小伙伴，可以先看看单链表

LinkedList底层是双向链表，先来简单的了解一下双向链表的基本结构。双向链表即有两个指针，头指针和尾指针，头指针指向当前元素的前一个元素，尾指针指向当前元素的后一个元素。描述的可能有点抽象，下面来看一下双向链表的结构图。

具有头结点和尾结点的空链表图
在这里插入图片描述
链表头的头结点为空，尾结点指向链表尾；链表尾的头结点指向链表头，尾结点指向空。

具有头结点和尾结点的双向链表图
在这里插入图片描述
图中除了链表头和链表尾，还有两个结点。除了链表头和链表尾，其他结点的两个指针都是指向前后结点的。

对双向链表有所了解后，在来看LinkedList的源码就会轻松很多。

LinkedList继承关系

继承实现的接口和类

  • LinkedList继承于AbstractSequentialList，实现了List、Deque、Cloneable、java.io.Serializable这些接口。
  • LinkedList继承了AbstractSequentialList，AbstractSequentialList是AbstractList子类，实现了最基本的增删改查方法，其中的所有的方法都需要根据迭代器来实现。
  • LinkedList实现了List接口，可以进行队列操作，提供了相关的添加、删除、修改、遍历等功能。
  • LinkedList实现了Deque接口，可以进行双端队列操作。
  • LinkedList实现了Cloneable接口，可以调用Object.clone方法返回该对象的浅拷贝
  • LinkedList实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

LinkedList类源码

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

继承关系图

在这里插入图片描述

源码解析

LinkedList属性

LinkedList底层是一个双向链表，所以属性中定义了两个指针，分别为指向链表头结点的指针和指向链表尾结点的指针。相比ArrayList少了很多属性。

//链表结点的个数
transient int size = 0;

//链表头
transient Node<E> first;

//链表尾
transient Node<E> last;

指针的类型是引用类型Node，Node是LinkedList的一个内部类。

源码如下

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

Node类，相当于一个结点，Node中包含了当前结点的元素值、头结点和尾结点属性和一个构造方法。

构造方法

LinkedList类提供了两个构造方法，无参构造方法和Collection<? extends E>类型参数构造方法。

无参构造方法

无参构造方法，就是实例一个空集合。

public LinkedList() {
}

Collection<? extends E>类型参数构造方法

public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

通过上述的继承关系图，可以知道Collection是一个集合。调用addAll()方法将集合C中元素添加到实例的集合中。

linkBefore(E e, Node succ)方法

linkBefore(E e, Node succ)方法在非空结点succ结点前插入结点。链表在插入结点时只需要改变指针的指向位置即可，所以插入结点的效率比较高。下图为插入结点的一个示意图。
在这里插入图片描述
在结点a和结点b之前插入结点x，即在非空结点b前插入结点x；虚线为插入之前指针的指向位置。

对插入结点有所了解后，来看一下LinkBefore方法的源码。

void linkBefore(E e, Node<E> succ) {
  	// 获取succ结点的头指针，即前驱
    final Node<E> pred = succ.prev;
    //实例一个新结点，头结点指向succ结点的前驱，尾结点指向succ。
    final Node<E> newNode = new Node<>(pred, e, succ);
    //succ结点的头结点指向新结点
    succ.prev = newNode;
    //如果succ结点的头指针为空，则把新结点newNode赋值为first
    if (pred == null)
        first = newNode;
    else
    	//否则改变succ结点的头指针，指向新结点
        pred.next = newNode;
    //元素个数添加
    size++;
    modCount++;
}

  • LinkBefore方法，先获取了指定的结点succ的前驱结点，在这两个结点中间插入新的结点。

  • 实例一个新的结点，新结点的头指针指向succ结点的前驱，尾结点指向secc，实现了插入操作。

  • 改变succ结点的头结点指向新结点。

  • 如果succ结点的头指针为空，则把新结点newNode赋值为first，否则改变succ结点的头指针，指向新结点。元素个数添加，实现完整的插入操作。

linkFirst(E e)方法

linkFirst(E e)方法在链表的头添加结点。

private void linkFirst(E e) {
	//定义一个结点f并赋值为链表头
    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++;
}

在链表的头部添加结点可以分为以下几步

  • 定义一个结点f并赋值为链表头。
  • 实例一个新结点，结点元素为参数e，新结点的尾指针指向链表头。
  • 更新链表头first为新的结点。
  • 如果链表头为空，则链表为空，链表尾赋值为新结点。否则链表头的尾结点指向新结点。使得新结点为链表头，实现了添加结点在链表头。

linkLast(E e)方法

linkLast(E e)方法在链表尾添加结点。linkLast(E e)方法和linkFirst(E e)方法实现很相似，一个是添加结点在链表头部，一个是添加结点在链表尾部。

void linkLast(E e) {
	//定义一个结点l并赋值为链表尾
    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++;
}

在链表的尾部添加结点可以分为以下几步

  • 定义一个结点l并赋值为链表尾。
  • 实例一个新结点，新结点的头指针指向链表尾，即新结点为新的链表尾。
  • 更新链表尾last为新的结点。
  • 如果链表尾为空，则链表为空，链表头赋值为新结点。否则链表尾的头结点指向新结点。使得新结点为链表尾，实现了添加结点在链表尾。

add(E e)方法

LinkedList集合中add方法添加结点是添加在链表的末尾。直接调用linkLast(e) 方法实现的，添加成功返回true。源码如下

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

addLast(E e)方法

addLast方法，添加结点到链表的末尾，直接调用的linkLast方法，源码如下

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

addFirst(E e)方法

addFirst方法，添加结点到链表的头部，直接调用的linkFirst方法，源码如下

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

add(int index, E element)方法

add(int index, E element)方法在指定位置插入结点。

public void add(int index, E element) {
	//判断index位置是否合法
   	checkPositionIndex(index);

	//如果index等于链表长度，则调用linkLast方法插入到链表末尾
    if (index == size)
        linkLast(element);
    else
    	//否则调用linkBefore方法，插入到指定结点前
    	//node(index)方法，返回index位置的结点对象
        linkBefore(element, node(index));
}

add(int index, E element)方法会先对index位置进行判断，是否合法。

之后判断index和链表长度是否相等，如果相等则调用linkLast方法，插入结点到链表末尾；如果不相等，则调用linkBefore方法，插入到指定结点前。

checkPositionIndex(index)方法判断index位置是否合法，不合法则抛出异常，源码如下

private void checkPositionIndex(int index) {
	//index位置不合法，则抛出异常
  	if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

//判断index是合法，小于0或者大于链表元素个数都是不合法的，返回false
private boolean isPositionIndex(int index) {
 	return index >= 0 && index <= size;
}

node(index)方法，返回index位置的结点对象，源码如下

Node<E> node(int index) {
	//判断index位置的结点是在链表的前半部分还是后半部分
    if (index < (size >> 1)) {
    	//从链表头开始往后遍历，遍历到第index个结点返回
        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;
    }
}

size()方法

size()方法，返回链表中结点的数量。定义属性是定义了一个size变量，用于保存链表中结点的数量，所以这里直接返回size变量即可，源码如下

public int size() {
   	return size;
}

remove(Object o)方法

remove(Object o)方法，根据元素值删除结点。遍历链表，找到元素等于o的结点，调用unlink(x)方法，删除结点x。

public boolean remove(Object o) {
	//判断元素o是否为空
    if (o == null) {
    	//遍历链表，找到结点元素等于null的结点
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
            	//调用unlink方法，删除结点
                unlink(x);
                return true;
            }
        }
    } else {
    	//遍历链表，找到结点元素等于o的结点
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

unlink(x)方法，删除结点x。删除结点和添加结点很相似，只需要移动头结点和尾结点的指针。删除结点的示意图如下
在这里插入图片描述
从上图可以看出，删除一个结点，只需要改变指向该结点的指针指向，使该结点和链表断开链接即可。

结点X为准备删除的结点、结点a为结点X的前驱结点、结点b为结点X的后续结点。

unlink(x)方法源码如下

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 = next;
    } else {
    	//如果不为空，则把前驱结点的尾结点指向准备删除结点的后继结点
        prev.next = next;
        //删除结点的头结点指向空
        x.prev = null;
    }

	//如果删除结点的后继结点为空，则把删除结点的前驱结点设置为链表尾
    if (next == null) {
        last = prev;
    } else {
    	//如果不为空，则把后继结点的头结点指向准备删除结点的前驱结点
        next.prev = prev;
        //删除结点的尾结点指向空
        x.next = null;
    }
	
	//删除结点的元素值置为空
    x.item = null;
    //元素数量自减
    size--;
    modCount++;
    return element;
}

remove(int index)方法

remove(int index)方法删除index位置的结点，理解了上面的remove(Object o)删除结点的方法，在来看remove(int index)方法就很简单了。

public E remove(int index) {
	//判断index位置是否合法
 	checkElementIndex(index);
 	//调用node方法，返回index位置的结点，unlink方法，删除结点
    return unlink(node(index));
}

remove(int index)方法先判断index位置参数是否合法，之后调用node(index)方法返回index位置的结点对象，在调用unlink方法删除结点。

get(int index)方法

get(int index)方法返回index位置的结点对象的元素值。

public E get(int index) {
	//判断位置信息是否合法
   	checkElementIndex(index);
   	//node(index)方法返回index位置的结点对象
    return node(index).item;
}

get(int index)方法，先判断位置参数是否合法，合法则调用node(index)方法返回index位置的结点对象，之后访问对象的item元素并返回。

set(int index, E element)方法

set(int index, E element)方法修改指定位置的结点元素值并返回修改之前的值。

public E set(int index, E element) {
	//判断位置参数是否合法
   	checkElementIndex(index);
   	//通过node方法获取index位置的结点对象
    Node<E> x = node(index);
    //保存index位置结点的元素值
    E oldVal = x.item;
    //修改元素值
    x.item = element;
    //返回修改前的元素值
    return oldVal;
}

修改结点的元素值可以分为以下几步

  • 判断位置参数是否合法。

  • 通过node方法获取index位置结点对象。

  • 保存index位置结点的元素值，用于返回。

  • 修改index位置结点的元素值。

  • 返回修改前的元素值。

clear()方法

clear()方法清空链表中所有结点

public void clear() {
   	//循环遍历链表
    for (Node<E> x = first; x != null; ) {
    	//获取到每个结点，把每个结点的头指针、尾指针、结点元素全置为空
        Node<E> next = x.next;
        x.item = null;
        x.next = null;
        x.prev = null;
        x = next;
    }
    //链表头和链表尾置为空
    first = last = null;
    //链表结点数量设置为0
    size = 0;
    modCount++;
}

clear()方法清空链表中的所有结点，遍历链表中所有结点，把每个结点的头指针、尾指针、结点元素全置为空；链表头和链表尾设置为空；初始链表结点数量为0。

总结

  • LinkedList底层是双向链表实现的，不会浪费空间。
  • 新增和删除元素时效率会很高。
  • 根据索引位置访问元素效率会比较低。
  • 线程不安全。
小马 同学
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第三章 LinkedList源码解析1
08-04
LinkedList源码解析 LinkedList是Java中的一种链表实现，它的底层是一个环形双向链表。在 LinkedList 中，节点之间通过引用相互连接，形成一个链表结构。LinkedList 提供了多种方法来操作链表，包括添加、删除、...
LinkedList集合分析
qq_45609245的博客
02-20 213
文章目录前言LinkedList重要源码分析内部私有类NodelinkFirst(E e)方法llinkLast(E e)方法linkBefore(E e, Node succ)方法node(int index)方法 前言 说到集合，Java中所有集合的总接口时Collection，Collection规范了集合基本的操作方法，同时约束了所有集合都存在泛型约束。下面是集合的组织架构： interface Collection<E> interface List<E> exte
LinkedList
qq_42545382的博客
07-28 134
LinkedList学习 开始学习LinkedList首先要了解它所使用的数据结构。LinkedList使用的是Node,先了解LinkedList中的私有静态类Node。 Node中共有三个字段： item：存储数据 next：该字段存储下一个Node的地址 prev：该字段存储上一个Node的地址 private static class Node<E> { E item; Node<E> next; Node<E
Java8集合之LinkedList
CRUD工程师
01-16 689
参考资料： 《Java集合：LinkedList详解》 《Collection - LinkedList源码解析》 《LinkedList》 写在开头：本文为个人学习笔记，内容比较随意，夹杂个人理解，如有错误，欢迎指正。 目录 一、基础概念 1、基本属性 2、构造方法 二、修改 三、查找 1、node 2、get 3、peek 4、element 四、增加 ...
Java集合源码解析 - LinkedList
暖冬微寒的博客
08-07 163
概述 LinkedList是一个以双向链表实现的List，同时可作为队列(FIFO)与栈(LIFO)使用(非线程安全) UML类图 LinkedList实现了List接口，提供了增删改查的基础操作； LinkedList实现了Serializable接口，可以被序列化； LinkedList实现了Cloneable接口，可以被克隆； LinkedList实现了Deque接口，可作为双端队列； 源码解析 属性 //节点个数 transient int size = 0; //链表首节点 transient
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等集合框架的底层实现源码大白话解读。
链表及LinkedList详解
chaosongcc的博客
07-17 2597
何为链表 链表就是一种使用对象引用变量来创建对象间的链的数据结构.对象引用变量可用于创建链式结构,对象引用变量所存储的特点地址一般无关紧要.换句话说,重要的是能够使用引用变量来访问对象,而对象在内存中的位置并不重要 下面这个类就是一个链式结构: public class Person{ private String name; private int age; p...
LinkedList源码分析
渣渣飞的博客
08-26 462
Java集合框架LinkedList的底层结构即相关介绍空参和含参构造器linkFirst(E e)linkLast(E e)对比ArrayList LinkedList的底层结构即相关介绍 基于jdk1.8 的源码分析(后续更新) 上图： 底层结构：双向链表 LinkedList中维护了两个重要的属性，first，和last,分别指向首节点和尾节点。每个节点(N...
Java LinkedList中add、addFirst、offerFirst、push方法的区别
脐橙
09-28 7543
该文章建立于JDK8的基础上谈论。 复习Java基础中对于以下方法产生了疑惑。 add addFirst addLast offer offerFirst offerLast push 经百度(无力吐槽)查询出的内容基本上就是 addXXX、offerXXX、push方法的所处在接口不一样 该说法没毛病 将对象e插入队列尾部，成功返回true，失败（没有空间）返回false 该说法...
JAVA Vector源码解析和示例代码
09-04
【JAVA Vector 源码解析和示例代码】 在Java编程语言中，`Vector`类是集合框架的一部分，早在JDK 1.0版本就已经存在。`Vector`类继承自`AbstractList`并实现了`List`, `RandomAccess`, `Cloneable`等接口，提供了...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值