Java源码分析2-LinkedList

最新推荐文章于 2023-03-16 20:26:20 发布
最新推荐文章于 2023-03-16 20:26:20 发布
阅读量81 收藏
点赞数
分类专栏： 源码分析 文章标签： LinkedList
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lu322313/article/details/95535639
版权

以下内容基于JDK1.8
以下内容将分为如下几个章节

  • 概述
  • 继承关系图
  • 相关成员变量
  • 内部静态类
  • 构造函数
  • 常用方法
  • 优缺点

概述

  • List和Deque接口的双链表实现
  • 实现了所有List相关的操作
  • 接收所有类型元素,包括Null
  • 对于双向链表，所有操作都是可以预期的
  • 索引到列表中的操作将从开头或结尾遍历列表，以较接近指定索引为准
  • 非线程安全

继承关系图

LinkedList继承关系图

相关成员变量

//记录元素个数
transient int size = 0;

/**
 * 记录链表第一个元素
 */
transient Node<E> first;

/**
 * 记录链表最后一个元素
 */
transient Node<E> last;

内部静态类

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

构造函数

  1. 无参构造函数
public LinkedList() {}
  1. 传入参数为Collection子类的构造函数
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}
  • 2.1 addAll(Collection<? extends E> c)方法
    • size表示元素个数,结合下文可知此时为插入列表索引
public boolean addAll(Collection<? extends E> c) {
	//size为列表元素个数,
	return addAll(size, c);
}
  • 2.2 通过索引新增元素 addAll(int index, Collection<? extends E> c)方法

public boolean addAll(int index, Collection<? extends E> c) {
	//校验索引是否越界
	//判断index >= 0 && index <= size,若为false,则抛出IndexOutOfBoundsException
    checkPositionIndex(index);
	//将传入集合转为数组
    Object[] a = c.toArray();
    int numNew = a.length;
    //判断数组长度是否为0
    if (numNew == 0)
        return false;
	
	//分别记录上一个和索引所在的节点
    Node<E> pred, succ;
    //判断传入索引是否与列表长度一致
    if (index == size) {
    	//一致说明在列表末尾添加元素
        succ = null;
        //最后一个节点就变成了新插入元素的上一个节点
        pred = last;
    } else {
    	//通过索引找出对应节点,相当在pred和succ间插入元素
        succ = node(index);
        //那么当前上一个节点为索引对应节点的上一个
        pred = succ.prev;
    }
	
	//迭代数组,
	//在pred后不断的新新增元素,
	//pred的下一个节点为插入的第一个节点,插入的第一个节点的上一个节点为pred
	//第一个节点的下一个节点为插入的第二个节点,插入的第二个节点的上一个节点为插入的第一个节点
	//以此类推.....
    for (Object o : a) {
    	//根据List存储的类型对数组中的元素进行强制类型转换,此处可能会报错ClassCastException
        @SuppressWarnings("unchecked") E e = (E) o;
        //构造一个新节点
        Node<E> newNode = new Node<>(pred, e, null);
        //如果上一个节点为空,及list为空
        if (pred == null){
        	//第一个元素为当前的新节点
        	first = newNode;
        }else{
        	//上一个元素的下一个元素为新节点
        	pred.next = newNode;
        }
        
        //最后上一个元素为新节点    
        pred = newNode;
    }
    
	//此判断等价于index == size
    if (succ == null) {
    	//最后一个元素为上述for循环完成后的最后一个新节点
        last = pred;
    } else {
    	//相当在pred和succ间插入元素,所以最后一个元素为上述for循环完成后的最后一个新节点的下一个元节点succ
    	//succ的上一个节点为最后一个新节点
        pred.next = succ;
        succ.prev = pred;
    }
	//元素个数=当前元素个数+数组长度
    size += numNew;
    //操作次数+1,相当于版本号
    modCount++;
    return true;
}
  • 2.3 通过索引找出对应的节点Node<E> node(int index)方法
Node<E> node(int index) {
    // assert isElementIndex(index);
	//判断索引是否小于size>>1,及size/2
    if (index < (size >> 1)) {
    	//若索引小于size/2,则通过向后查找的方式查找对应索引的节点
        Node<E> x = first;
       	//从列表的一个位置开始查找元素
        for (int i = 0; i < index; i++){
        	x = x.next;
        }  
        return x;
    } else {
    	//若索引大于size/2,则通过向前查找的方式查找对应索引的节点
        Node<E> x = last;
        for (int i = size - 1; i > index; i--){
        	x = x.prev;
        }
        return x;
    }
}

通过该构造函数可知,LinkedList是以链表的方式存储数据,导致通过索引添加元素的效率极低

常用方法

  1. 在列表末尾添加单个元素add(E e)方法
public boolean add(E e) {
	//在列表末尾添加元素
    linkLast(e);
    return true;
}
  • 1.1 在列表末尾添加元素linkLast(E e)方法
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++;
}

分析完以上代码后,可总结出一个规律,LinkedList新增元素时,需要经过如下步骤

  • 创建一个新节点,并指明其上一个节点
  • 修改上一个节点的下一个节点
  • 若在列表头,则需要修改头节点
  • 若在尾,则需要修改尾节点

另外,LinkedList也存在线程安全的问题,并发操作时也会发生相互覆盖导致数据丢失的问题

  1. 在列表指定位置添加单个元素add(E e)方法
public void add(int index, E element) {
	//判断索引是否越界
    checkPositionIndex(index);
	
    if (index == size){
    	//当索引值等于size,即在列表尾插入元素
    	linkLast(element);
    }else{
    	//当索引值不等于size,表示在列表前部插入元素
    	//在调用linkBefore之前,先调用node方法,找出索引对应的节点
    	linkBefore(element, node(index));
    }   
}
  • 2.1 在指定节点前部插入元素linkBefore(E e, Node<E> succ)方法
void linkBefore(E e, Node<E> succ) {
	//相当于在succ.prev()和succ间插入节点
	//那么新节点的prev=succ.prev(),新节点的next()=succ

    //获取到指定节点的上一个元素
    final Node<E> pred = succ.prev;
    //声明新节点的上一个节点为pred,下一个节点为succ,置为e
    final Node<E> newNode = new Node<>(pred, e, succ);
    //修改succ的上一节点为新节点
    succ.prev = newNode;
    if (pred == null){
    	//若指定节点的上一个节点为空,则说明指点节点为头节点,插入新节点后新节点变为对手
    	first = newNode;
    }else{
    	//修改指定节点的上一节点的下一个节点为新节点
    	pred.next = newNode;
    }
        
    size++;
    modCount++;
}
  1. 删除头节点remove()方法
public E remove() {
    return removeFirst();
}
  • 3.1 删除头节点removeFirst()方法
 public E removeFirst() {
 	//获取头节点
    final Node<E> f = first;
    
    if (f == null){
    	//头节点为空,则抛出异常
    	throw new NoSuchElementException();
    }
   	//解除头节点连接
    return unlinkFirst(f);
}
  • 3.2 解除头节点连接unlinkFirst(Node<E> f)方法
private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    //取出头节点存储值
    final E element = f.item;
    //获取头节点的下一个节点
    final Node<E> next = f.next;
    //将头节点的值置为空
    f.item = null;
    //将头节点置为空
    f.next = null; // help GC
    //将头节点的下一个节点置为头节点
    first = next;
    if (next == null){
    	//新头节点为空,则尾结点也为空
    	last = null;
    }else{
    	//新头节点前一节点也置为空
    	next.prev = null;
    }
        
    size--;
    modCount++;
    return element;
}
  1. 删除尾节点```removeLast()````方法
public E removeLast() {
   final Node<E> l = last;
   //判断尾结点是否为空
   if (l == null){
   		//尾结点为空则抛出异常
   		throw new NoSuchElementException();
   }
   //解除尾节点相关连接    
   return unlinkLast(l);
}
  • 4.1 解除尾节点相关连接unlinkLast(Node<E> l)方法
private E unlinkLast(Node<E> l) {
    //取出尾结点对应值
    final E element = l.item;
    //取出尾结点的前一节点
    final Node<E> prev = l.prev;
    //将尾结点的存储值置为空
    l.item = null;
    //将尾结点的前一节点置为空
    l.prev = null; // help GC
    //将列表的尾结点设置为前一节点---删除尾结点的关系链
    last = prev;
    if (prev == null){
    	//若上一节点为空,则说明头节点也为空
    	first = null;
    }else{
    	//将新尾结点的下一节点置为空
    	prev.next = null;
    }   
    size--;
    modCount++;
    return element;
}
  1. 根据值删除节点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;
}
  • 5.1 根据节点解除链接E unlink(Node<E> 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;
}

综上,

  • LinkedList的优点
    • 插入和删除较快
  • 缺点
    • 非线程安全
    • 根据索引查询,节点越多,效率越多
L.T.F.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java集合系列之LinkedList源码分析
08-27
Java集合系列之LinkedList源码分析 概述： 本文详细介绍了Java集合系列之LinkedList的源码分析，主要介绍了LinkedList的底层实现、成员变量、构造器、增删改查方法等。LinkedList是一种基于双向链表的数据结构，...
Java LinkedList源码分析
01-20
简介 　LinkedList 是一个常用的集合类，用于顺序存储元素。 LinkedList 经常和 ArrayList 一起被提及。...本文分析 LinkedList 的具体实现。 　继承关系 　public class LinkedList 　extends AbstractS
Java源码分析 - LinkedList
BlueLzy的个人博客
07-03 3118
什么是LinkedList 和ArrayList不同，LinkedList是基于链表实现的线性数据结构。节点之间访问不是通过下标进行，而是通过指针。同时，LinkedList实现了List接口和Deque接口。在Deque接口中提供了许多有用的方法，我们下面会选一些详细说。 这是LinkedList里面Node结构(静态内部类)： private static class Node<E> { E item; Node<E> next;
java集合源码分析②----LinkedList添加元素的过程
myjess’s blog
08-12 437
LinkedList底层是一个双向链表 由下图源码看看出LinkedList实现了Deque接口，所以LinkedList还可以作为队列和栈来使用。 静态内部类Node，表示双向链表的结点： LinkedList添加元素的过程（add过程） final Node l = last; //当前节点的最后一个节点 final Node newNode = new Node<>(l, e, null); 定义新节点 示例： LinkedList<String> list =
java核心基础--jdk源码分析学习--LinkedList
热门推荐
老专家的博客
12-13 1万+
java.util.LinkedList1. 内部由内部类Node存储单节点数据，双向循环链表private jdk源码
Java基础 集合-LinkedList源码分析
sun1995sun的博客
03-10 387
LinkedList双向链表源码分析 import java.util.Iterator; import java.util.LinkedList; import java.util.NoSuchElementException; /** * @author 小黄debug on 2022/3/10 * @version 1.0 */ public class LinkedListCRUD { public static void main(String[] args) {
java LinkedList 源码分析（通俗易懂)
Cyan_RA9的博客
03-16 1775
java 集合篇章——LinkedList类内容分享。包含LinkedLIst类的底层实现和源码分析。
Java源码分析 - LinkedList 源码分析
Akrisllen的博客
10-26 246
LinkedList 源码分析LinkedList 简介LinkedList 线程安全的实现合理的创建标题，有助于目录的生成如何改变文本的样式 LinkedList 简介 Java源码中的linked list 实际上是数据结构中的双向链表（Doubly-linked list）。实现了List和 Dequeue 接口。针对index的操作会从头或者尾开始进行遍历。LinkedList 线程不安全...
Java数据结构源码分析-LinkedList
CWeeYii的专栏
06-05 518
1.LinkedListLinkedList是通过双向链表来维护链表的顺序性。 首先，我们看下类的构成，LinkedList通过两个iterator来顺序和倒序的访问数据。public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java
Java进阶之----LinkedList源码分析
Zhengw博客专栏
04-12 9362
今天在看LinkedList的源代码的时候，遇到了一个坑。我研究源码时，发现LinkedList是一个直线型的链表结构，但是我在baidu搜索资料的时候，关于这部分的源码解析，全部都说LinkedList是一个环形链表结构。。我纠结了好长时间，还以为我理解错了，最后还是在Google搜到了结果：因为我看的源码是1.7的而baidu出来的几乎全部都是1.6的。而且也没有对应的说明。在1.7之后，or
Java源码分析-LinkedList双向链表
weixin_39561657的博客
03-27 1506
简单说下链表和和数组的区别，数组寻址快，遍历快。链表操作效率高，比如插入，删除。而两者的优点正是对方的缺点。可以理解成，数组每个元素都很团结，靠的很紧，所以想拆开他们就很难，而链表是松散的，而联系就是他们的就是指向前一个或者后一个兄弟的部分，所以想插入或者拿走一个就很简单。拿ArrayList来说，就是基于数组实现的，由于数组是一个有序的集合体，每次用add或者remove方法都会调用一个数组拷贝...
源码分析-java-LinkedList
千念飞羽的专栏
07-21 1617
LinkedListAPI文档LinkedList是一个基于双向链表的List和Deque的实现。对所有元素（包括null内）实现了所有可选的操作。所有的操作性能可以从双端队列的list来估计。基于下标的操作需要从list的头或者尾（根据具体位置）遍历到相应的位置才可以特别注意这个实现不是同步的。如果多线程访问同时访问一个list，且只是有一个线程结构性的调整了list，这样的操作需要外部特性保持同
java LinkedList源码详解及实例
08-31
3. **源码分析**： - `getFirst()`和`getLast()`通过直接访问`first`和`last`属性来获取元素，这两个属性分别保存链表的第一个和最后一个节点。 - `removeFirst()`和`removeLast()`通过`unlinkFirst(Node<E> f)`和...
Java基于JDK 1.8的LinkedList源码详析
08-26
今天我们将深入分析LinkedList的源码，了解其内部实现机制和特点。 1. 构造函数 LinkedList提供了两个构造函数，一个是无参构造函数`public LinkedList() {}`，另一个是带参数的构造函数`public LinkedList...
Java 集合之LinkedList源码分析
01-20
Java API中提供了链表的Java实现—LinkedList下。LinkedList是通过节点的连接实现链表的数据结构，向linkedList中插入或删除元素的速度是特别快，而随机访问的速度相对较慢，这个是由于链表本身的性质造成的，在链表...
Pygments-1.2-py2.6.egg
最新发布
06-19
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
大数据可视化大屏页面-广西矿产资源大数据监管平台+源代码+演示地址
06-19
1、资源内容地址： https://blog.csdn.net/2301_78627004/article/details/136655536 2、代码特点：内含运行结果，不会运行可私信，参数化编程、参数可方便更改、代码编程思路清晰、注释明细，都经过测试运行成功，功能ok的情况下才上传的。 3、适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
大数据可视化大屏页面-双数智慧公卫-传染病督导平台+源代码+演示地址
06-19
1、资源内容地址： https://blog.csdn.net/2301_78627004/article/details/136655536 2、代码特点：内含运行结果，不会运行可私信，参数化编程、参数可方便更改、代码编程思路清晰、注释明细，都经过测试运行成功，功能ok的情况下才上传的。 3、适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
小程序版python语言pytorch框架训练识别非机动车辆-不含数据集图片-含逐行注释和说明文档.zip
06-19
本代码是基于python pytorch环境安装的。 下载本代码后，有个环境安装的requirement.txt文本 如果有环境安装不会的，可自行网上搜索如何安装python和pytorch,这些环境安装都是有很多教程的，简单的 环境需要自行安装,推荐安装anaconda然后再里面推荐安装python3.7或3.8的版本，pytorch推荐安装1.7.1或1.8.1版本 首先是代码的整体介绍 总共是3个py文件，十分的简便 且代码里面的每一行都是含有中文注释的,小白也能看懂代码 然后是关于数据集的介绍。 本代码是不含数据集图片的，下载本代码后需要自行搜集图片放到对应的文件夹下即可 在数据集文件夹下是我们的各个类别,这个类别不是固定的，可自行创建文件夹增加分类数据集 需要我们往每个文件夹下搜集来图片放到对应文件夹下，每个对应的文件夹里面也有一张提示图，提示图片放的位置 然后我们需要将搜集来的图片，直接放到对应的文件夹下，就可以对代码进行训练了。 运行01数据集文本生成制作.py,是将数据集文件夹下的图片路径和对应的标签生成txt格式,划分了训练集和验证集 运行02深度学习模型训练.py,
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、付费专栏及课程。

余额充值