LinkedList部分源码分析

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量114 收藏
点赞数 1
分类专栏： java 数据结构 文章标签： java 数据结构 链表 列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47954009/article/details/115428129
版权

一、LinkedList概述

1.1 表ADT

介绍ArrayList集合和LinkedList集合之前我们必须要对表ADT（抽象数据类型）有一定的了解。
抽象数据类型（ADT）
抽象数据类型是带有一组操作的一些对象的集合。

表ADT
我们将处理形如A0，A1，A2，……，An-1的一般的表。我们说这个表的大小是N。大小为0的特殊的表称为空表。
对于除空表外的任何表，我们说Ai后继Ai-1并称Ai-1前驱Ai。

表ADT的两种实现方式

表的数组实现
对于表的所有操作都可以通过使用数组来实现。
表的链表实现
链表由一系列节点组成，这些节点不必在内存中相连。每个节点均还有表元素和到包含该元素后继元的节点的链。

表的链表实现
为了避免插入和删除的线性开销，我们需要保证表可以不连续存储，否则表的每个部分都可能需要整体移动。
链表有一系列节点组成，这些节点不必在内存中相连。每个节点均含有表元素和到包含该元素后继元的节点的链（link）。我们称之为next链。最后一个单元的next链引用null。
如果每个节点持有一个指向它在表中的前去节点的链，我们称之为双链表。
在java语言中，对于ListADT的链表实现中最为流行的就是LinkedList类。

1.2 LinkedList类

在实现中采用双链表数据结构。对顺序访问进行了优化，向List中插入和删除元素的速度较快，随机访问则相对较慢。随机访问是指检索位于特定索引位置的元素。LinkedList单独具有addFirst()、addLast（）、getFirst（）、getLast（）、removeFirst（）、removeLast（）方法、这些方法使得LinkedList可以作为堆栈，队列，双向队列使用。

LinkedList的最基础的存储单元–Node

private static class Node<E> {
        E item;  //value
        Node<E> next; //指向下一个节点的指针
        Node<E> prev;//指向上一个节点的指针

        //构造方法
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

图示：
在这里插入图片描述
prev：指向前驱元节点的指针，item：存储数据，next：指向后继元节点的指针
链表中的每一个Node的存储是不连续的。
LinkedList集合的结构图：
在这里插入图片描述

二、LinkedList源码

2.1 LinkedList继承结构和层级关系

源码代码：

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

图示：
在这里插入图片描述

  • LinkedList<>:表示linkedlist支持泛型
  • extends AbstractSequentialList：这个类提供了List的一个骨架实现接口，以尽量减少实现此接口所需的工作量由“顺序访问”数据存储（如链接列表）支持。对于随机访问数据（如数组），应使用AbstractList优先于此类。
  • implements AbstractSequentialList：意味着LinkedList元素是有序的,可以重复的,可以有null元素的集合.
  • implements Deque：Deque是Queue的子接口,Queue是一种队列形式,而Deque是双向队列,它支持从两个端点方向检索和插入元素.
  • implements Cloneable：实现了Cloneable接口,标识着可以它可以被复制.注意,ArrayList里面的clone()复制其实是浅复制
  • implements Serializable:标识着集合可被序列化。
    **

2.2 LinkedList的属性

    transient int size = 0;

    transient Node<E> first;

    transient Node<E> last;

size:链表的长度
first:链表的头节点
last：链表的尾节点

2.3 LinkedList的构造方法

//无参构造
public LinkedList() {
    }
//构造列表通过指定的集合
public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

ArrayList拥有三个构造方法。而LinkedList只有两个构造方法。
思考:为什么LinkedList没有提供public LinkedList(int initialCapacity)这种构建指定大小列表的构造方式?
因为ArrayList有这种构造方法public ArrayList(int initialCapacity),ArrayList提供这种构造方法的好处在于在知道需要多大的空间的情况下,可以按需构造列表,无需浪费多余的空间和不必要的生成新数组的操作.而LinkedList可以很轻松动态的增加元素(O(1)),所以没必要一开始就构造一个有很多元素的列表,到时需要的时候再按需加上去就行了.

2.4 LinkedList的主要方法

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;  //更新last
        //如果链表为空，新节点即为first
        if (l == null)
            first = newNode;
        //如果链表不为空，添加前的未节点的next指向新节点
        else
            l.next = newNode;
        //链表的大小加一
        size++;
        modCount++;
    }

add(int index, E element)方法

    //在指定位置上添加元素
    public void add(int index, E element) {
        //检查插入位置的索引的合理性
        checkPositionIndex(index);
        //如果插入位置是尾部，与add（E e）相同
        if (index == size)
            linkLast(element);
       //如果不是在尾部插入，调用linkBefore
        else
            linkBefore(element, node(index));
    }

    //检查index与size的关系，
    private void checkPositionIndex(int index) {
        //调用isPositionIndex方法，方法如下，不做解释。
        //如果不合理则抛出异常
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }
    //如果不尾部插入时，调用的linkBefore
    //参数： e-要添加的元素   succ-添加前在index位置上的节点
    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        //定义一个常量index位置节点的前驱元
        final Node<E> pred = succ.prev;
        //创建一个节点，前驱指向pred 后继指向succ
        final Node<E> newNode = new Node<>(pred, e, succ);
        //succ的前驱指向新节点
        succ.prev = newNode;
        //如果pred为空，即新节点为first
        if (pred == null)
            first = newNode;
        //否则pred的后继指向新节点
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

    //参数node（index）的方法。
    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;
        }
    }

get(int index)方法

    //根据下标查找元素的数据
    public E get(int index) {
         //元素下标的合理性检查
        checkElementIndex(index);
        //返回数据
        return node(index).item;
    }
     //检查元素下标的合理性
    private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    //检查元素下标的合理性
    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }
    //根据下标拿到对应的节点
    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;
        }
    }

remove(int index)方法

    //根据下标删除对应的节点
    public E remove(int index) {
        //检查下标的合理性
        checkElementIndex(index);
        //将节点删除
        return unlink(node(index));
    }
    //检查下标的合理性
    private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    //将节点删除的具体方法
    E unlink(Node<E> x) {
        // assert x != null;
        //将节点的数据赋值给element
        final E element = x.item;
        //节点的后继
        final Node<E> next = x.next;
        //节点的前驱
        final Node<E> prev = x.prev;
        //如果节点是frist，frist指向下一个节点
        if (prev == null) {
            first = next;
        } else {
            //如果不是frist，上一个节点的后继指向这个节点的后继元
            prev.next = next;
            //节点的前驱指向null
            x.prev = null;
        }
         //如果节点是last，last指向节点的前驱元
        if (next == null) {
            last = prev;
        } else {
        //如果不是last，下一个节点的前驱指向这个节点的前驱元
            next.prev = prev;
            //节点的后继指向null
            x.next = null;
        }
        //删除节点的值
        x.item = null;
        size--;
        modCount++;
        //返回删除的数据
        return element;
    }

clear（）方法

        //清空列表
        public void clear() {
        // Clearing all of the links between nodes is "unnecessary", but:
        // - helps a generational GC if the discarded nodes inhabit
        //   more than one generation
        // - is sure to free memory even if there is a reachable Iterator
        //遍历链表的每一个节点，
        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置空
        first = last = null;
        //将链表的size归零
        size = 0;
        modCount++;
    }

** indexOf(Object o)方法**

    //返回元素在链表的下标
    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) {
                //遍历equls查找
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }
insist-2020
关注
专栏目录
LinkedList底层源码分析
2401_84413531的博客
04-19 791
还有更多的Redis、MySQL、JVM、Kafka、微服务、Spring全家桶等学习笔记这里就不一一列举出来。
LinkedList 部分源码
10-24
### LinkedList部分源码解析 #### 一、简介 `LinkedList`是Java集合框架的一个重要组成部分，它基于双向链表实现，既支持`List`接口也实现了`Deque`接口，因此可以作为列表、栈或者队列使用。双向链表的每个节点...
深入理解 LinkedList 及底层源码分析
好好学java
05-03 1270
1、继承树结构：2、LinkedList 定义LinkedList继承了 AbstractSequentialList 类，实现了 List 接口、Deque 接口、Cloneable 接口、java.io.Serializable 接口。LinkedList实现了 List 接口，即能对它进行队列操作，提供了相关的添加、删除、修改、遍历等功能。LinkedList实现了 Deque 接口，即能将 LinkedList 当作双端队列使用。LinkedList。
LinkedList的源码分析（一）
时代新人的博客
10-09 307
通过源码可以看到node(int index)方法遍历查找指定元素索引处的非空节点的时候是分成两部分来遍历查找的，当要查的元素的index索引小于列表大小的一半时候，进行index之前的部分查找；当要查的元素的index索引大于列表大小的一半时候，进行index之后的部分查找，这样可以节省很多时间，否则 会在非空节点之前插入该元素，这是会先通过node(int index)方法遍历查找指定元素索引处的非空节点，此时的时间复杂度是。如果要插入的索引是列表的大小，则将该元素追加到列表的末尾，同1）中的。
LinkedList源码分析
小鲁蛋的博客
10-30 414
总体来看 LinkedList 的源码并不复杂，基本都是双向链表的基本操作，大家感兴趣的可以看一下。LinkedList源码深度解析以及迭代器机制【一万字】_刘Java的博客-CSDN博客_linkedlist迭代器LinkedList 源码解析 - 掘金 (juejin.cn)LinkedList(JDK1.8)源码解析_ThinkWon的博客-CSDN博客​​​​​​​。
java LinkedList 源码分析（通俗易懂)
Cyan_RA9的博客
03-16 2084
java 集合篇章——LinkedList类内容分享。包含LinkedLIst类的底层实现和源码分析。
java linkedlist源码分析_LinkedList源码解析
weixin_28318011的博客
02-24 145
# 第一章 LinkedList介绍## 1.1 引导语LinkedList 集合底层是一个双向链表结构，具有增删快，查询慢的忒点,内部包含大量操作首尾元素的方法。适用于集合元素先入先出和先入后出的场景，在队列源码中被频繁使用。## 1.2 整体架构LinkedList 底层数据结构是一个双向链表，整体结构如下图所示：上图代表了一个双向链表结构，可以通过前面的节点找到后面的节点,也可以通过后面的节...
LinkedList 源码分析
今天有划水吗？
09-04 565
概括了 LinkedList 存储结构，常用方法解析，使用场景等。
LinkedList集合源码分析
weixin_45278293的博客
03-06 485
LinkedList 使用双向链表来存储元素，不需要连续的内存空间来存储元素，所以不需要扩容。一般作为队列，直接操作头部和尾部。支持存储或删除相同的元素，且支持存储null，存储的元素有序。存在相同多个值是，会删除靠近头结点的值。查找元素只能遍历查找，效率慢O(n)，删除，插入快O（1）。根据元素值查找，只能从头结点开始遍历。如果根据 位置查找，会从距离头结点或尾结点近的一方开始遍历。不是线程安全的。
Java LinkedList源码分析
一不小心做了程序员的博客
07-16 152
Java LinkedList源码分析 首先我们看下链表的数据结构 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a6MhIevm-1626419988391)(E:\Study\java集合源码分析\链表结构.png)] 从上面可以看出，链表是一个节点连着一个节点的。节点包含三个属性，分别为他的前缀、后缀、以及节点的值。链表是通过节点的next属性进行连接的，这样就形成了我们看到的逻辑结构。注意：当链表中只要一个节点的时候，链表的头结点和尾结点都是这个节点 链表的定义：链
LinkedList源码分析_016.pdf
09-13
《LinkedList源码解析》 LinkedList是Java集合框架中的一员，它是AbstractSequentialList的子类，同时也实现了List、Deque和Cloneable、Serializable接口。LinkedList作为双向链表，支持快速的添加、删除元素，尤其...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 292
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 824
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1389
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 899
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 268
默认对常规Session的理解和使用，如何使用Set-Cookie。
spring6 笔记(3 万字详解)
2301_79083000的博客
10-29 1284
尚硅谷spring笔记带你一套掌握spring
linkedlist源码分析
04-27
下面是部分 LinkedList 的源码分析。 ```cpp template class list { protected: struct list_node { list_node* prev; list_node* next; T data; }; ... }; ``` 在这段代码中，`list_node` 是双向链表的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值