LinkedList源码分析

最新推荐文章于 2024-07-05 17:30:16 发布
最新推荐文章于 2024-07-05 17:30:16 发布
阅读量100 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42448721/article/details/108394757
版权

１元素的存储结构

在LinkedList中，每一个元素都是Node存储，Node拥有一个存储值的item与一个前驱prev和一个后继next，如下：

// 典型的链表结构
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继承关系如下图:
在这里插入图片描述

３相关属性

	// LinkedList节点个数
    transient int size = 0;

    /**
     * Pointer to first node. 
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;	//指向头结点

    /**
     * Pointer to last node.  指向尾节点
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;		//指向头结点

从源码中我们可以看出，LinkedList采用双链表的结构进行存储

４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) {
	    // 1.添加位置的下标的合理性检查
        checkPositionIndex(index);

	    // 2.将集合转换为Object[]数组对象
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

		// 3.得到插入位置的前继节点和后继节点
        Node<E> pred, succ;
        if (index == size) {
	        // 从尾部添加的情况：前继节点是原来的last节点；后继节点是null
            succ = null;
            pred = last;
        } else {
           // 从指定位置（非尾部）添加的情况:前继节点就是index位置的节点，后继节点是index位置的节点的前一个节点
            succ = node(index);
            pred = succ.prev;
        }
		
		// 4.遍历数据，将数据插入
        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 = newNode;
        }

        if (succ == null) {
	        // 如果是从尾部开始插入的，则把last置为最后一个插入的元素
            last = pred;
        } else {
	        // 如果不是从尾部插入的，则把尾部的数据和之前的节点连起来
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;  // 链表大小+num
        modCount++;  // 修改次数加1
        return true;
    }

5主要方法

5.1 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 = newNode;  // 更新尾部节点为需要插入的节点
        if (l == null)
		    // 如果空链表的情况：同时更新first节点也为需要插入的节点。（也就是说：该节点既是头节点first也是尾节点last）
            first = newNode;
        else
	        // 不是空链表的情况：将原来的尾部节点（现在是倒数第二个节点）的next指向需要插入的节点
            l.next = newNode;
        size++; // 更新链表大小和修改次数，插入完毕
        modCount++;
    }

5.2 add(int index, E element)方法

	// 作用：在指定位置添加元素
    public void add(int index, E element) {
	    // 检查插入位置的索引的合理性
        checkPositionIndex(index);

        if (index == size)
	        // 插入的情况是尾部插入的情况：调用linkLast（）解释如上。
            linkLast(element);
        else
	        // 插入的情况是非尾部插入的情况（中间插入）：linkBefore（）见下面。
            linkBefore(element, node(index));
    }

    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        final Node<E> pred = succ.prev;  // 得到插入位置元素的前继节点
        final Node<E> newNode = new Node<>(pred, e, succ);  // 创建新节点，其前继节点是succ的前节点，后接点是succ节点
        succ.prev = newNode;  // 更新插入位置（succ）的前置节点为新节点
        if (pred == null)
	        // 如果pred为null，说明该节点插入在头节点之前，要重置first头节点 
            first = newNode;
        else
	        // 如果pred不为null，那么直接将pred的后继指针指向newNode即可
            pred.next = newNode;
        size++;
        modCount++;
    }

5.3 get(int index)方法

    public E get(int index) {
	    // 元素下表的合理性检查
        checkElementIndex(index);
        // node(index)真正查询匹配元素并返回
        return node(index).item;
    }

	// 作用：查询指定位置元素并返回
    Node<E> node(int index) {
        // assert isElementIndex(index);

		// 如果索引位置靠链表前半部分，从头开始遍历
        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;
        }

5.4 remove(int index)方法

  // 返回元素在链表中的索引，如果不存在则返回-1
  public int indexOf(Object o) {
        int index = 0;
        // 如果元素为null，进行如下循环判断
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
        // 元素不为null.进行如下循环判断
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }

6 Duque接口

6.1 addFirst(E e)方法

  // 作用：在链表头插入指定元素
   public void addFirst(E e) {
        linkFirst(e);
    }

    private void linkFirst(E e) {
        final Node<E> f = first; // 获取头部元素
        final Node<E> newNode = new Node<>(null, e, f); // 创建新的头部元素（原来的头部元素变成了第二个）
        first = newNode;

		// 链表头部为空，（也就是链表为空）
        if (f == null)
            last = newNode; // 头尾元素都是e
        else
            f.prev = newNode;  // 否则就更新原来的头元素的prev为新元素的地址引用
        size++;
        modCount++;
    }

5.2 addLast(E e)方法

// 作用：在链表尾部添加元素e
   public void addLast(E e) {
		// 上面已讲解过，参考上面。add()方法
        linkLast(e);
    }

6.3 push(E e)方法

	// 作用:往链表头部添加元素e
    public void push(E e) {
        addFirst(e);
    }

6.4 getFirst()方法

// 作用：得到头元素
public E getFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}

6.5 getLast()方法

	// 作用：得到尾部元素
    public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

6.6 peek()方法

	// 作用：返回头元素，并且不删除。如果不存在也不错，返回null
   public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }

6.7 peekFirst()方法

	//  作用：返回头元素，并且不删除。如果不存在也不错，返回null
    public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
     }

6.8 peekLast()方法

	// 作用：返回尾元素，如果为null,则就返回null
    public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
    }

6.9 poll()方法

	// 作用：返回头节点元素，并删除头节点。并将下一个节点设为头节点。
   public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

6.10 pollFirst()方法

	// 作用：返回头节点，并删除头节点，并将下一个节点设为头节点。
    public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

6.11 pollLast()方法

	// 作用：返回尾节点，并且将尾节点删除，并将尾节点的前一个节点置为尾节点
    public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }

6.12 pop()方法

	// 作用：删除头节点，如果头结点为null.则抛出异常
    public E pop() {
        return removeFirst();
    }

    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

push(E e)方法

	// 作用：将元素添加到头部
    public void push(E e) {
        addFirst(e);
    }

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

    private void linkFirst(E e) {
        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++;
    }

后记

其中的关于序列化、Iterator这两块，与ArrayList的实现也是不尽相同的，故在此可参考ArrayList中的解析。

飞翼111
关注
深入理解LinkedList
weixin_46272350的博客
08-15 1063
什么是LinkedList 概念： LinkedList是基于链表实现的，所以先讲解一下什么是链表。链表是一种线性的存储结构，意思是将要存储的数据存在一个存储单元里面，这个存储单元里面除了存放有待存储的数据以外，还存储有其下一个存储单元的地址（下一个存储单元的地址是必要的，有些存储结构还存放有其前一个存储单元的地址），每次查找数据的时候，通过某个存储单元中的下一个存储单元的地址寻找其后面的那个存储单元。理解：LinkedList是一个双向链表，也就是说list中的每个元素，在存储自身值之外，还 额外存储
node 存储过程_源码会说话之LinkedList的Node
weixin_39881802的博客
11-28 258
使用过ArrayList的小伙伴们都知道ArrayList实现了java.util.List接口，间接的实现了java.util.Collection接口，是我们日常开发过程使用频繁的有序数据集合。在java中还提供了一些其他的有序数据集合，今天的主角就是其中的LinkedList集合。小伙伴们有没有想过，有了ArrayList，为什么还需要LinkedList？要想回答这个问题，就需要...
数据结构与算法学习（二）链式存储结构LinkedList源码分析
qq_21158307的博客
09-29 250
待编辑
List集合之LinkedList（一）通过源码看特性
程序员阿甘的博客
03-27 442
思维导图 (以下源码来自jdk1.8.0_282) 数据结构 双向链表 由于Java中并没有像数组那样直接提供双向链表的类，所以我们这里需要先实现双向链表数据结构。 双向链表的关键实现是 “链接节点” 设计。因为链接节点具有承上启下的作用。只有具备承上启下的能力才能实现双向联系。 private static class Node<E> { E item; Node<E> next; Node<E&gt.
LinkedList源码解析
qq_32073629的博客
08-07 771
深入理解LinkedList源码
LinkedList 源码分析
努力学习，努力爱你！
09-11 586
E item;// 节点值// 指向的下一个节点（后继节点）// 指向的前一个节点（前驱结点）// 初始化参数顺序分别是：前驱结点、本身节点值、后继节点。
java LinkedList 源码分析（通俗易懂)
Cyan_RA9的博客
03-16 1999
java 集合篇章——LinkedList类内容分享。包含LinkedLIst类的底层实现和源码分析。
ArrayList和LinkedList源码分析
weixin_42614150的博客
04-14 171
ArrayList:初始化时没有直接创建存储数据的数组，在第一次添加元素时，会创建长度为10的数组，当数组长度不够用时，会自动扩容，每次扩容1.5倍，对象创建时类似于单例中的懒汉式，延迟数组的创建，节省了内存空间。 //扩容方法 private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; //每次扩容1.5倍 .
java-Linkedlist源码分析
weixin_41247813的博客
07-05 678
LinkedList` 通过 `first` 和 `last` 字段分别指向链表的首节点和尾节点，这样可以高效地进行头部和尾部的插入和删除操作。如果链表为空，则新节点既是 `first` 也是 `last`。- `unlinkFirst(Node f)`：断开头部节点的链接，并返回节点中的元素。- `unlinkLast(Node l)`：断开尾部节点的链接，并返回节点中的元素。- `unlink(Node x)`：断开指定节点的链接，并返回节点中的元素。
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源码分析
01-20
LinkedList是通过节点的连接实现链表的数据结构，向linkedList中插入或删除元素的速度是特别快，而随机访问的速度相对较慢，这个是由于链表本身的性质造成的，在链表中，每个节点都包含了前一个节点的引用，后一个...
智慧旅游景区解决方案PPT(50页).pptx
最新发布
09-21
智慧旅游解决方案利用云计算、物联网和移动互联网技术，通过便携终端设备，实现对旅游资源、经济、活动和旅游者信息的智能感知和发布。这种技术的应用旨在提升游客在旅游各个环节的体验，使他们能够轻松获取信息、规划行程、预订票务和安排食宿。智慧旅游平台为旅游管理部门、企业和游客提供服务，包括政策发布、行政管理、景区安全、游客流量统计分析、投诉反馈等。此外，平台还提供广告促销、库存信息、景点介绍、电子门票、社交互动等功能。 智慧旅游的建设规划得到了国家政策的支持，如《国家中长期科技发展规划纲要》和国务院的《关于加快发展旅游业的意见》，这些政策强调了旅游信息服务平台的建设和信息化服务的重要性。随着技术的成熟和政策环境的优化，智慧旅游的时机已经到来。 智慧旅游平台采用SaaS、PaaS和IaaS等云服务模式，提供简化的软件开发、测试和部署环境，实现资源的按需配置和快速部署。这些服务模式支持旅游企业、消费者和管理部门开发高性能、高可扩展的应用服务。平台还整合了旅游信息资源，提供了丰富的旅游产品创意平台和统一的旅游综合信息库。 智慧旅游融合应用面向游客和景区景点主管机构，提供无线城市门户、智能导游、智能门票及优惠券、景区综合安防、车辆及停车场管理等服务。这些应用通过物联网和云计算技术，实现了旅游服务的智能化、个性化和协同化，提高了旅游服务的自由度和信息共享的动态性。 智慧旅游的发展标志着旅游信息化建设的智能化和应用多样化趋势，多种技术和应用交叉渗透至旅游行业的各个方面，预示着全面的智慧旅游时代已经到来。智慧旅游不仅提升了游客的旅游体验，也为旅游管理和服务提供了高效的技术支持。
智慧旅游实景三维智慧景区建设方案PPT(70页).pptx
09-21
智慧旅游解决方案利用云计算、物联网和移动互联网技术，通过便携终端设备，实现对旅游资源、经济、活动和旅游者信息的智能感知和发布。这种技术的应用旨在提升游客在旅游各个环节的体验，使他们能够轻松获取信息、规划行程、预订票务和安排食宿。智慧旅游平台为旅游管理部门、企业和游客提供服务，包括政策发布、行政管理、景区安全、游客流量统计分析、投诉反馈等。此外，平台还提供广告促销、库存信息、景点介绍、电子门票、社交互动等功能。 智慧旅游的建设规划得到了国家政策的支持，如《国家中长期科技发展规划纲要》和国务院的《关于加快发展旅游业的意见》，这些政策强调了旅游信息服务平台的建设和信息化服务的重要性。随着技术的成熟和政策环境的优化，智慧旅游的时机已经到来。 智慧旅游平台采用SaaS、PaaS和IaaS等云服务模式，提供简化的软件开发、测试和部署环境，实现资源的按需配置和快速部署。这些服务模式支持旅游企业、消费者和管理部门开发高性能、高可扩展的应用服务。平台还整合了旅游信息资源，提供了丰富的旅游产品创意平台和统一的旅游综合信息库。 智慧旅游融合应用面向游客和景区景点主管机构，提供无线城市门户、智能导游、智能门票及优惠券、景区综合安防、车辆及停车场管理等服务。这些应用通过物联网和云计算技术，实现了旅游服务的智能化、个性化和协同化，提高了旅游服务的自由度和信息共享的动态性。 智慧旅游的发展标志着旅游信息化建设的智能化和应用多样化趋势，多种技术和应用交叉渗透至旅游行业的各个方面，预示着全面的智慧旅游时代已经到来。智慧旅游不仅提升了游客的旅游体验，也为旅游管理和服务提供了高效的技术支持。
基于深度学习实现的半监督学习例子.zip
09-21
深度学习是机器学习的一个子领域，它基于人工神经网络的研究，特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征，这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分： 1. **神经网络（Neural Networks）**：深度学习的基础是人工神经网络，它是由多个层组成的网络结构，包括输入层、隐藏层和输出层。每个层由多个神经元组成，神经元之间通过权重连接。 2. **前馈神经网络（Feedforward Neural Networks）**：这是最常见的神经网络类型，信息从输入层流向隐藏层，最终到达输出层。 3. **卷积神经网络（Convolutional Neural Networks, CNNs）**：这种网络特别适合处理具有网格结构的数据，如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络（Recurrent Neural Networks, RNNs）**：这种网络能够处理序列数据，如时间序列或自然语言，因为它们具有记忆功能，能够捕捉数据中的时间依赖性。 5. **长短期记忆网络（Long Short-Term Memory, LSTM）**：LSTM 是一种特殊的 RNN，它能够学习长期依赖关系，非常适合复杂的序列预测任务。 6. **生成对抗网络（Generative Adversarial Networks, GANs）**：由两个网络组成，一个生成器和一个判别器，它们相互竞争，生成器生成数据，判别器评估数据的真实性。 7. **深度学习框架**：如 TensorFlow、Keras、PyTorch 等，这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数（Activation Functions）**：如 ReLU、Sigmoid、Tanh 等，它们在神经网络中用于添加非线性，使得网络能够学习复杂的函数。 9. **损失函数（Loss Functions）**：用于评估模型的预测与真实值之间的差异，常见的损失函数包括均方误差（MSE）、交叉熵（Cross-Entropy）等。 10. **优化算法（Optimization Algorithms）**：如梯度下降（Gradient Descent）、随机梯度下降（SGD）、Adam 等，用于更新网络权重，以最小化损失函数。 11. **正则化（Regularization）**：技术如 Dropout、L1/L2 正则化等，用于防止模型过拟合。 12. **迁移学习（Transfer Learning）**：利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就，但它也面临着一些挑战，如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
关于APx测试耳机音频的参数设置及步骤 关于APx测试耳机音频的参数设置及步骤
09-21
关于APx测试耳机音频的参数设置及步骤 关于APx测试耳机音频的参数设置及步骤
jQuery背景可滑动的导航菜单代码，鼠标经过导航时导航背景可滑动，兼容主流浏览器
09-21
jQuery背景可滑动的导航菜单代码，鼠标经过导航时导航背景可滑动，兼容主流浏览器 使用方法： 1、引入reset.css、index.css、jquery-1.7.2.min.js库文件，及jquery.movebg.js插件 2、在文件中加入<!-- 代码 开始 --><!-- 代码 结束 -->区域代码 3、移动的滑动可根据需要自由修改外观
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、付费专栏及课程。

余额充值