Java集合框架 ——— LinkedList 源码分析

最新推荐文章于 2024-08-26 19:43:03 发布
最新推荐文章于 2024-08-26 19:43:03 发布
阅读量316 收藏
点赞数 11
分类专栏： Java 文章标签： java 开发语言 后端 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48471044/article/details/134119109
版权

相关博客

简介

LinkedList 是一个基于双向链表实现的集合类，经常被拿来和 ArrayList 做比较。

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

LinkedList 继承自AbstractSequentialList，它决定了 LinkedList 只能支持按次序访问。此外 LinkedList 还实现了 Deque 接口，它具有双端队列的特性，支持从两端插入和删除元素，方便实现栈和队列等数据结构。因此 LinkedList 实现了很多队列的方法，在开发中也可以当做一个堆栈来使用。

Node 节点

LinkedList 私有内部 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;

/**
 * 指向第一个节点的指针。
 */
transient Node<E> first;

/**
 * 指向最后一个节点的指针。
 */
transient Node<E> last;

构造方法

/**
 * 无参构造器
 */
public LinkedList() {
}

/**
 * 按照集合的迭代器返回的顺序构造包含指定集合的元素的列表。
 */
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

插入元素

add()

add() 方法有两个版本：

  • add(E e)：在集合尾部插入元素，时间复杂度为 O(1)。
  • add(int index, E element): 在指定位置插入元素。由于链表的特性，指定位置插入时需要移动指针，所以时间复杂度为 O(n)。
/**
 * 将指定的元素追加到此列表的末尾。
 */
public boolean add(E e) {
    // 调用方法插入到末尾
    linkLast(e);
    return true;
}

/**
 * 在此列表中的指定位置插入指定的元素。将当前位于该位置的元素（如果有）和任何后续元素向右移动（将一个元素添加到其索引中）。
 *
 * @param index 		要插入指定元素的索引
 * @param element 		要插入的元素
 */
public void add(int index, E element) {
    // 检查 index 是否合法，linkedList
    checkPositionIndex(index);
    
	// 如果index 等于 size，相当于添加在末尾，直接调用 linkLast 方法
    if (index == size)
        linkLast(element);
    else
        // 如果在集合中间，调用linkBefore，插入元素并且移动后续元素
        linkBefore(element, node(index));
}

相关方法

node方法在下文查找元素中介绍，checkPositionIndex 方法比较简单，判断一下 index 在不在 0 到 size 之间就好了，可以自己看一下。

/**
 * 链接 e 作为最后一个元素。
 */
void linkLast(E e) {
    // 临时保存原集合最后一个元素
    final Node<E> l = last;
    // 即将加入到列表的元素节点
    final Node<E> newNode = new Node<>(l, e, null);
    // 重新设置最后一个节点
    last = newNode;
    if (l == null)
    	// 如果 原集合 最后一个元素是 null，表示集合为空，则把第一个元素也赋值成 newNode
        first = newNode;
    else
        // 指向新的后继节点
        l.next = newNode;
    size++;
    modCount++;
}

/**
 * 在非 null 节点 succ 之前插入元素 e
 */
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.prev = newNode;
    if (pred == null)
        // 如果 succ 是头结点，重设头结点
        first = newNode;
    else
        // 指向新的后继节点
        pred.next = newNode;
    size++;
    modCount++;
}

addFirst() & addLast()

/**
 * 在此列表的开头插入指定的元素。
 */
public void addFirst(E e) {
    linkFirst(e);
}

/**
 * 将指定的元素追加到此列表的末尾。
 */
public void addLast(E e) {
    linkLast(e);
}

相关方法

linkFirst 方法和 linkLast方法实现思路类似，可以参考上文自行理解

/**
 * 链接 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++;
}

其他插入元素方法

其余的方法只是简单的调用一下其他已经实现的方法，不在过多介绍

/**
 * Adds the specified element as the tail (last element) of this list.
 *
 * @param e the element to add
 * @return {@code true} (as specified by {@link Queue#offer})
 * @since 1.5
 */
public boolean offer(E e) {
    return add(e);
}

// Deque operations

/**
 * Inserts the specified element at the front of this list.
 *
 * @param e the element to insert
 * @return {@code true} (as specified by {@link Deque#offerFirst})
 * @since 1.6
 */
public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}

/**
 * Inserts the specified element at the end of this list.
 *
 * @param e the element to insert
 * @return {@code true} (as specified by {@link Deque#offerLast})
 * @since 1.6
 */
public boolean offerLast(E e) {
    addLast(e);
    return true;
}

查找元素

get()

/**
 * 返回此列表中指定位置的元素。
 *
 * @param index 要返回的元素的索引
 */
public E get(int index) {
    // 查看 index 是否合法
    checkElementIndex(index);
    return node(index).item;
}

相关方法

/**
 * 返回指定元素索引处的（非 null） 节点。
 */
Node<E> node(int index) {
    // 判断一下元素索引下标是否合法
    // assert isElementIndex(index);

    // 判断下标位置，选择正向遍历还是反向遍历
    if (index < (size >> 1)) {
        Node<E> x = first;
        // 下标在集合前半段，从前向后遍历找到下标 index，返回节点
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        // 下标在集合后半段，从后向前遍历找到下标 index，返回节点
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

getFirst() & getLast()

/**
 * 返回此列表中的第一个元素。
 */
public E getFirst() {
    // 通过 first 属性得到头结点
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}

/**
 * 返回此列表中的最后一个元素。
 */
public E getLast() {
    // 通过 last 属性得到尾结点
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}

其他方法

其余的三个检索方法也只是通过 first 和 last 属性返回节点

/**
 * Retrieves, but does not remove, the head (first element) of this list.
 *
 * @return the head of this list, or {@code null} if this list is empty
 * @since 1.5
 */
public E peek() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}

/**
 * Retrieves, but does not remove, the first element of this list,
 * or returns {@code null} if this list is empty.
 *
 * @return the first element of this list, or {@code null}
 * if this list is empty
 * @since 1.6
 */
public E peekFirst() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}

/**
 * Retrieves, but does not remove, the last element of this list,
 * or returns {@code null} if this list is empty.
 *
 * @return the last element of this list, or {@code null}
 * if this list is empty
 * @since 1.6
 */
public E peekLast() {
    final Node<E> l = last;
    return (l == null) ? null : l.item;
}

删除元素

list 的删除方法

/**
 * 从此列表中删除指定元素的第一个匹配项（如果存在）。
 *
 * @param o  要从此列表中删除的元素
 */
public boolean remove(Object o) {
    if (o == null) {
        // 遍历
        for (Node<E> x = first; x != null; x = x.next) {
            // 第一个符合条件的item
            if (x.item == null) {
                // 移除
                unlink(x);
                return true;
            }
        }
    } else {
        // 和条件为 true 的逻辑相同
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

/**
 * 从此列表中删除所有元素。此调用返回后，列表将为空。
 */
public void clear() {
    // 遍历，把节点全部变为null，方便GC回收
    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;
    size = 0;
    modCount++;
}

相关方法

/**
 * 取消链接非空节点 x。
 */
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;
        // 将当前节点的 next 指针置为 null，方便 GC 回收
        x.prev = null;
    }

    if (next == null) {
        // 要删除的是尾结点，重设尾结点
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    // 将当前节点元素置为 null，方便 GC 回收
    x.item = null;
    size--;
    modCount++;
    return element;
}

Deque 的删除方法

通过 Deque 接口实现的删除方法，主要是通过 LinkedList 内部私有方法unlinkFirst和unlinkLast实现，可以参考 unlink 方法和clear方法。

/**
 * Removes and returns the first element from this list.
 *
 * @return the first element from this list
 * @throws NoSuchElementException if this list is empty
 */
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

/**
 * Removes and returns the last element from this list.
 *
 * @return the last element from this list
 * @throws NoSuchElementException if this list is empty
 */
public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}

相关方法

/**
 * 取消链接非 null 的第一个节点 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;
}

/**
 * 取消链接非空的最后一个节点 l。
 */
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;
}
Flobby529
关注
  • 11
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java并发源码集合-DeepLeaner_Java:Java集合框架源码，多线程，jdk5新特性泛型，并发知识总结学习
05-24
这个名为"DeepLeaner_Java"的资源集合主要涵盖了Java集合框架的源码分析，多线程技术，以及JDK5引入的新特性——泛型，并发知识的综合总结。以下是对这些知识点的详细讲解： 1. **Java集合框架源码**：Java集合框架...
Thinking in Java——自己手写的代码
07-28
3. **集合框架**：Java集合框架是程序设计的重要部分，涵盖了List、Set、Map接口以及ArrayList、LinkedList、HashSet、HashMap等实现类的使用。 4. **异常处理**：介绍如何使用try-catch-finally语句块进行错误处理...
Java常用集合框架——LinkedList源码分析
weixin_44868854的博客
11-26 140
第一次自己单撸一个数据结构的源码，还是挺吃力的，但是理解方面更深了
Java集合框架——LinkedList
FantasticPan的博客
11-12 272
本文基于JDK1.8，代码中方法头的注释都是对照源码翻译过来的 自顶向下阅读 类头 public class LinkedList&amp;lt;E&amp;gt; extends AbstractSequentialList&amp;lt;E&amp;gt; implements List&amp;lt;E&amp;gt;, Deque&amp;lt;E&amp;gt;, Cloneable, java.io.Serializ
java集合框架——LinkedList和源码分析
随风的博客
06-06 498
LinkedList简介LinkedList与Collection的关系： LinkedList是一个继承与AbatractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList实现了List接口，能对它进行队列操作。 LinkedList实现了Deque接口，即能将LinkedList当作双
java集合框架04——LinkedList和源码分析
武哥聊编程
04-12 5772
上一章学习了ArrayList，并分析了其源码，这一章我们将对LinkedList的具体实现进行详细的学习。依然遵循上一章的步骤，先对LinkedList有个整体的认识，然后学习它的源码，深入剖析LinkedList。 LinkedList简介     首先看看LinkedList与Collection的关系：
Java7/8集合框架——LinkedList源码分析
weixin_33877885的博客
04-21 108
java.util.LinkedList 本文的结构： 一、LinkedList的特点及与ArrayList的比较 二、LinkedList的内部实现 三、LinkedList添加元素 四、LinkedList查找元素 五、LinkedList删除元素 六、LinkedList修改元素 七、Java8中的改动 一、LinkedList的特点及与ArrayList的比较 ...
Java集合框架 ——— LinkedList 基础使用
weixin_48471044的博客
10-30 322
采用链表存储，所以在头尾插入或者删除元素不受元素位置的影响，时间复杂度为 O(1)；如果是要在指定位置 i 插入和删除元素的话， 时间复杂度为 O(n) ，因为需要先移动到指定位置再插入和删除。我们在项目中一般是不会使用到 LinkedList 的，需要用到 LinkedList 的场景几乎都可以使用 ArrayList 来代替，并且，性能通常会更好。
Java类集框架 —— LinkedList源码分析
weixin_34239592的博客
09-22 66
在JDK1.7之前，LinkedList是采用双向环形链表来实现的，在1.7及之后，Oracle将LinkedList做了优化，将环形链表改成了线性链表。本文对于LinkedList的源码分析基于JDK1.8。 LinkedList既然是通过一个双向线性链表来实现，那么肯定就能够很轻易的找到链表的第一个节点和最后一个节点，在源码中可以看到有这两个字段： transient Node&lt;E&gt...
Java集合框架整理(五)——LinkedList源码分析
hesheng1024的博客
06-05 249
title: Java集合框架整理(五)——LinkedList源码分析 tag: Java 文章目录title: Java集合框架整理(五)——LinkedList源码分析 tag: JavaLinkedList源码分析添加add删除removegetset其他方法总结 LinkedList源码分析 LinkedList：链表实现的集合 先看看类的继承关系 public class Linke...
Java集合-04LinkedList源码解析
Jzedy的博客
12-17 186
回顾与对比 上一章讲到了ArrayList,你也可以在 github上查看,ArrayList底层基于数组，所以支持随机访问， 因为你可以通过下标访问到具体的数据，而LinkedList则是基于链表，这种不同造成它俩有各自的优缺点； ArrayList随机访问数据快，而在中间增加删除较慢，LinkedList相反，随机访问较慢，在中间增加删除较快； 访问前面已经提到ArrayList是支持随机访...
java毕业设计之ArrayList，LinkList链表接口实现源码.zip
07-17
在本Java毕业设计项目中，主要探讨了两种重要的数据结构——ArrayList和LinkedList，它们都是Java集合框架中的核心组件，属于List接口的实现类。ArrayList和LinkedList各有特点，适合不同的应用场景，理解并掌握这两...
JAVA实现斗地主源码.zip
06-14
- **集合框架**：用于存储和管理牌组，如使用ArrayList或LinkedList存储玩家的手牌，用HashMap存储出牌记录。 2. **游戏逻辑** - **发牌机制**：随机算法确保公平地将54张牌分配给三个玩家。 - **判断胜负**：...
java8集合源码分析-DesignPatterns_TypeScript:TypeScript版设计模式
06-04
Java 8 集合框架是 Java 编程中不可或缺的一部分，它提供了高效的数据结构和算法，如 ArrayList、LinkedList、HashMap 和 HashSet 等。在深入理解这些集合类的源码时，我们可以学习到许多优秀的设计模式和编程技巧。...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 114
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 570
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
如何使用ssm实现模具制造企业订单跟踪管理系统+vue
最新发布
a253399414的博客
08-26 478
【代码】ssm模具制造企业订单跟踪管理系统+vue
基于jenkins部署maven项目
静水深流
08-26 187
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
Java集合框架：LinkedList与ArrayList特性对比
本文主要介绍了Java集合框架中的LinkedList类，它是List接口的一个实现，支持null元素，并提供了在链表头部和尾部进行插入、删除和获取元素的特殊操作。LinkedList可作为堆栈、队列或双端队列使用。文章还提到了多...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值