[Java]-LinkedList 源码分析

已于 2022-10-28 18:46:37 修改
阅读量538 收藏
点赞数
文章标签： java 开发语言
于 2022-03-06 21:25:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pacifica_/article/details/123310080
版权

前言

源码中对 LinkedList 这个类给出了详细概述，大概意思为

是 List 接口跟 Deque 接口的双向链表实现，实现了所有可选的 list 操作，而且允许所有的类型存储，包括null
所有操作的执行都是在双向链表的结构上。通过索引进入 list 的操作会通过从链表头或者链表尾往另一端遍历来找到指定索引的位置然后进行操作，至于从头还是尾开始遍历，就要看指定的索引位置离头更近还是离尾更近
LinkedList 这个实现类并不是同步的，如果有多线程并发地访问了一个 LinkedList，且至少有一个线程修改了 list 的结构，那它就必须在外部进行同步 (添加或删除元素才属于对 list 结构的修改，不包括对某个元素的值进行修改)。这通常是通过在能自然封装 list 的某个对象上进行同步来实现的
如果没有这样的对象，那么 list 应该使用 Collections.synchronizedList 方法进行包装：
List list = Collections.synchronizedList(new LinkedList(…));
该类的迭代器 iterator 及 listIterator 是支持 fast-fail 机制的

在下面的具体方法分析中，可以看到有的方法实际上是在调用类中其它的方法，如 offer 方法实际上是在调用 add 方法，offerFirst 方法实际上是在调用 addFirst 方法，这是由于 LinkedList 既实现了 List<E> 接口，也实现了 Deque<E>，所以有一部分方法是重写 List 接口中的，一部分是重写 Deque 中的，而这两部分方法中，又有一些方法是相同作用的，所以就直接调用了

链表节点 Node

链表的每个节点的类型采用的是内部类 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 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;

size 表示当前 LinkedList 中存储的元素个数

first 以及 last 分别指向双向链表的头节点跟尾结点，而且存在这样的恒成立关系：要么 first 跟 last 都为 null，要么 first 节点有存值且前驱节点为 null，以及 last 节点有存值且其后续节点为 null，分别对应 LinkedList 为空表以及有存元素两种情况

构造函数

构造函数较为简单，即一个无参无其他行为的构造函数以及一个根据 Collection 集合来创建 LinkedList 的构造函数

public LinkedList() {
}

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

私有的操作

LinkedList 设置了几个私有的修改链表结构的方法：linkFirst()，linkLast()，linkBefore()，unlinkFirst()，unlinkLast()，unlink()

其它对用户提供的操作方法都是直接或间接地调用这些操作，在这些操作中，要注意的是，由于是双向链表，每对一个元素进行增或删操作时，要注意 其与前驱节点以及后继节点的联系 (引用关系)，特别是 操作前链表是不是空表，操作后链表会不会是空表：

//在链表头新增一个元素
private void linkFirst(E e) {
    final Node<E> f = first;
    //新增的节点就会成为新的头节点
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    //f为null说明原来是个空表，现在有了第一个节点，last也要指向它
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}
//在链表尾新增一个元素
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++;
}
//在链表中指定节点的前面插入一个新元素，该节点必须存值链表中
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.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}
//删除链表头节点，所传参数必须为链表的头节点
private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    final E element = f.item;
    final Node<E> next = f.next;
    //将相关的引用置为null才可以让GC进行内存回收
    f.item = null;
    f.next = null; // help GC
    first = next;
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}
//删除链表尾结点
private E unlinkLast(Node<E> l) {
    // assert l == last && l != null;
    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;
}
//删除链表中指定的节点，且指定的节点必须不为null
E unlink(Node<E> x) {
    // assert x != null;
    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;
}

添加元素

addFirst

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

在链表头部添加元素，直接调用 linkFirst 方法完成

addLast

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

在链表尾部添加元素，直接调用 linkLast 方法完成

add

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

add 方法是在在链表尾部添加元素，就是说它的 作用跟addLast是一样的
除此之外还有一个在指定索引位置添加元素的重载方法:

public void add(int index, E element) {
    checkPositionIndex(index);
    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

要在指定索引对应的地方添加一个元素，首先要判断这个索引所在的位置是不是允许元素存放。由于当前链表中共有 size 个元素，那么索引就是 [0,size - 1]，除此之外可以在链表尾添加一个元素，所以索引值等于size也是可以的，接下来进入 checkPositionIndex 方法看它的判断条件是不是这样：

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

继续查看 isPositionIndex：

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

可以看到其判断条件与前面认为的一致。判断索引合法就回到 add 方法中，当 index 值等于 size 时，直接调用 linkLast 方法将元素添加到链表尾；否则调用 linkBefore 方法将元素添加到原来 index 对应的节点的前面

以下操作就是 Deque 接口中的操作

offer

public boolean offer(E e) {
   return add(e);
}

offer 方法实际上是在调用 add 方法，即在链表尾添加元素

offerFirst

public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}

offerFirst 方法实际上是调用 addFirst 方法，即在链表头添加元素

offerLast

public boolean offerLast(E e) {
    addLast(e);
    return true;
}

offerLast 实际上是调用 addLast 方法，即在链表尾添加元素，跟 offer() 效果一样

push

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

push方法实际上是调用 addFirst 方法，即在链表头添加元素

删除元素

removeFirst

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

删除链表中第一个元素，即删除链表中第一个节点

removeLast

public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}

删除链表中最后一个元素，即删除链表中最后一个节点

以下操作就是面向Deque设置的操作

remove

//从头结点向后遍历，删除第一个所存元素值为o的节点
public boolean remove(Object o) {
	//可能有节点所存元素值就为null
    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) {
        	//经过测试，像这里这样调用equals并不是根据Object类中定义的一样根据地址是否一样来判断
        	//而是根据o跟x.item是什么类型(即该LinkedList的泛型)来使用其类中自己重写的equals方法，如String类
        	//当然，如果泛型就是Object，那还是会按照Object类中定义的一样使用内存地址是否一样来做判断
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

除此之外还有一个删除指定索引位置节点的重载方法：

public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

poll

public E poll() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

删除链表头节点，同时返回其所存元素的值

pollFirst

public E pollFirst() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

弹出第一个元素，跟poll一模一样

pollLast

public E pollLast() {
    final Node<E> l = last;
    return (l == null) ? null : unlinkLast(l);
}

弹出最后一个元素

pop

public E pop() {
    return removeFirst();
}

pop 方法实际上是调用 removeFirst 方法，所以在头节点为 null 的时候会抛出异常，这也是跟 poll 方法的区别所在，如果头节点为 null，poll 方法会返回 null 而不会抛出异常

获取元素值

getFirst

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

获取链表中第一个元素的值，即头节点所存元素的值，若不存在头节点会抛出异常

getLast

public E getLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}

获取链表中最一个元素的值，即尾节点所存元素的值，若不存在尾节点会抛出异常

get

get方法用于返回指定索引位置上链表节点的元素值

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

查找前要先判断索引对当前链表来说是否合法，合法的条件应该是 0 <= index < size
借助 checkElementIndex 方法

private void checkElementIndex(int index) {
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

继续看isElementIndex方法

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

发现判断条件确实是0 <= index < size。如果索引合法，就调用node(int 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;
    }
}

在概述的时候说过，“通过索引进入list的操作会通过从链表头或者链表尾往另一端遍历来找到指定索引的位置然后进行操作，至于从头还是尾开始遍历，就要看指定的索引位置离头更近还是离尾更近”，所以根据index是否小于size的二分之一，判断index所对应的节点离头节点更近还是离尾结点更近。如果index小于size的二分之一，说明index所对应的节点离头节点更近，所以从头节点开始往尾结点遍历查找第index个节点
在头尾结点中选取更近的节点开始遍历是为了尽可能地减少查找节点所花费的时间，因为LinkedList是链表结构，只要是查找操作都避免不了要进行O(n)的遍历链表操作，既然避免不了，那就只能尽可能地减少

peek

public E peek() {
    finalNode<E> f = first;
    return (f == null) ? null : f.item;
}

返回链表头节点所存元素值，若头节点为 null 则返回 null。在 栈 中，我们通常使用 peek 是来获取栈顶元素，也就是说，使用 LinkedList 作为栈时，我们应该默认链表头为 栈顶，链表尾为 栈底；同理，作为队列时，默认链表头为 队头，链表尾为 队尾

总结

LinkedList 既可以在链表头进行增删，也可以在链表尾进行增删，所以可以使用它来作为 队列 或者 栈 进行使用

ArrayList 的增删一定比 LinkedList 慢吗

  1. 如果增删是在末尾进行操作，ArrayList 可能不需要移动和复制数组，这时增删的速度是会比 LinkedList 快的
  2. 如果增删是在列表中间进行，由于 LinkedList 的时间花费主要是在遍历上，而 ArrayList 的时间花费主要是在删除元素后移动和复制数组上 (即调用 native 方法 System.arraycopy)
    LinkedList 的遍历速度是要慢于 ArrayList 的复制速度的，如果数据量是百万级，还是 ArrayList 要快
Pacifica_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中的LinkedList源码分析
Palpitate_fx的博客
03-26 1526
目录 LinkedList的基本结构 LinkedLisa的实现 LinkedList的构造方法 LinkedList 新增元素 LinkedList 删除元素 LinkedList 遍历元素 LinkedList get方法 LinkedList的基本结构 1.7中的结构： 1.6的结构 LinkedLisa的实现 LinkedList 是基于双向链表数据结构实现的，LinkedList 定义了一个 Node 结构，Node 结构中包含了 3 个部分：元素内容 i.
java源码分析---LinkedList
渔潭的博客
02-09 275
LinkedList源码分析 1、LinkedList体系结构 public class LinkedList&lt;E&gt; extends AbstractSequentialList&lt;E&gt; implements List&lt;E&gt;, Deque&lt;E&gt;, Cloneable, java.io.Serializable 通过源码我们看到Li...
Java集合之LinkedList源码分析
weixin_30611509的博客
01-02 102
概述 LinkedLIst和ArrayLIst一样, 都实现了List接口, 但其内部的数据结构不同, LinkedList是基于链表实现的(从名字也能看出来), 随机访问效率要比ArrayList差. 它的插入和删除操作比ArrayList更加高效, 但还是要遍历部分链表的指针才能移动到下标所指的位置, 只有在链表两头的操作能省掉移动, 如add(), addFirest(), removeL...
java-Linkedlist源码分析
最新发布
weixin_41247813的博客
07-05 666
LinkedList` 通过 `first` 和 `last` 字段分别指向链表的首节点和尾节点，这样可以高效地进行头部和尾部的插入和删除操作。如果链表为空，则新节点既是 `first` 也是 `last`。- `unlinkFirst(Node f)`：断开头部节点的链接，并返回节点中的元素。- `unlinkLast(Node l)`：断开尾部节点的链接，并返回节点中的元素。- `unlink(Node x)`：断开指定节点的链接，并返回节点中的元素。
Java进阶之----LinkedList源码分析
Zhengw博客专栏
04-12 9417
今天在看LinkedList的源代码的时候，遇到了一个坑。我研究源码时，发现LinkedList是一个直线型的链表结构，但是我在baidu搜索资料的时候，关于这部分的源码解析，全部都说LinkedList是一个环形链表结构。。我纠结了好长时间，还以为我理解错了，最后还是在Google搜到了结果：因为我看的源码是1.7的而baidu出来的几乎全部都是1.6的。而且也没有对应的说明。在1.7之后，or
java linkedlist源码_Java集合---LinkedList源码解析
weixin_35828357的博客
02-16 187
一、源码解析1、 LinkedList类定义2、LinkedList数据结构原理3、私有属性4、构造方法5、元素添加add()及原理6、删除数据remove()7、数据获取get()8、数据复制clone()与toArray()9、遍历数据：Iterator()二、ListItr一、源码解析1、LinkedList类定义。public class LinkedListextends Abstra...
java集合之LinkedList源码分析
花&败
01-24 444
一、LinkedList简介 1.1、LinkedList概述 LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。 LinkedList是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList实现List接口，能对它进行队列操作。 LinkedList实现Deque接口，即能将LinkedList当作双端队列使用。 LinkedList实现了Clo...
java linkedlist 序列化_Java集合-LinkedList源码分析
weixin_34737524的博客
02-24 308
1.数据结构-链表链表(Linked list)是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。链表的类型：单向链表：单...
ArrayList-LinkedList-源码.rar
10-10
《ArrayList与LinkedList源码解析》 在Java编程中，ArrayList和LinkedList是两种常见的动态数组，它们都是Java集合框架的一部分，提供了对元素存储和操作的功能。本篇将深入探讨ArrayList和LinkedList的内部实现...
Java--LinkedList真的比ArrayList添加元素快？Open JDK JMH带你揭开真相
热门推荐
JustinQin
08-31 2万+
【学习背景】 欢迎进来学习的小伙伴~ 不管你是学生，还是职场小白，还是入行1~3年的小伙伴，相信很多小伙伴在面试Java工作岗位时，发现LinkedList和ArrayList这个问题基本是必面的一道题， 【面试场景】 当面试官问到LinkedList和ArrayList的区别时，可能很多准备得不够充分的小伙伴第一反应的回答仅仅是这样的： LinkedList底层数据结构是链表，添加和删除元素效率比ArrayList高~ ArrayList底层数据结构是数组，查询效率比LinkedList高~ 面试官：哦
Java LinkedList源码分析
01-20
简介 　LinkedList 是一个常用的集合类，用于顺序存储元素。 LinkedList 经常和 ArrayList 一起被提及。...本文分析 LinkedList 的具体实现。 　继承关系 　public class LinkedList 　extends AbstractS
Java集合系列之LinkedList源码分析
08-27
Java集合系列之LinkedList源码分析 概述： 本文详细介绍了Java集合系列之LinkedList的源码分析，主要介绍了LinkedList的底层实现、成员变量、构造器、增删改查方法等。LinkedList是一种基于双向链表的数据结构，...
Java集合 LinkedList源码浅析
qq_32468603的博客
10-08 477
Java LinkedList源码浅析
java 集合ArrayList及LinkList源码分析
kanwoerzi
10-22 139
首先是ArrayList的继承体系,代码如下: Java代码 publicclassArrayList&lt;E&gt;extendsAbstractList&lt;E&gt; implementsList&lt;E&gt;,RandomAccess,Cloneable,java.io.Serializable public class ArrayList&l...
带你走进Java集合_LinkedList源码深入分析1
架构师之路
06-11 347
上几篇文章我们主要从源码角度分析了ArrayList，大家对ArrayList的学习，一定是掌握了ArrayList的用户，接下来再次总结一下ArrayList1.ArrayList的底层数据结构是数组，当数组满后需要对其进行扩容，我们知道数组的长度是不可以变化的，扩容时用到了数组的拷贝，把新扩容的数组赋值给底层的数组。 2.ArrayList对读多写少的业务效率非常高的，因为我们直接可以用到数组...
Java之LinkedList源码解读（JDK 1.8）
anxpp的博客
04-20 1万+
java.util.LinkedList     双向链表实现的List。    基于JDK 1.8。    没有使用标准的注释，并适当调整了代码的缩进以方便介绍。    里面很多方法的实现是一样的，不过可以让外界感觉其提供了更多的行为。    需要花比ArrayList更多一点的时间理解 package com.anxpp.thinkinjava.chapter11.sourse;
JavaSE基础知识(二十一)--Java集合(容器)之类LinkedList的源码分析(已修改)
ruidianbaihuo的博客
12-31 396
Java SE 是什么，包括哪些内容(二十一)？ 本文内容参考自Java8标准 顺序访问列表的一个常用实现类： LinkedList 类声明： public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Clonea...
Java 之LinkedList源码简单分析
qq_43164662的博客
11-11 623
LinkedList是我们常用的一个容器，简单分析LinkedList的源码，可以更好的了解LinkedList容器，了解它的数据结构、初始化、添加元素是如何实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值