Java源码系列之LinkedList

最新推荐文章于 2024-04-27 14:12:29 发布
置顶 最新推荐文章于 2024-04-27 14:12:29 发布
阅读量134 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wanmeilingdu/article/details/96322040
版权

一、介绍

  • 是一个继承于AbstractSequentialList的双向链表。它可以被当成堆栈、队列或双端队列进行操作。
  • 实现了List接口，能对它进行队列操作。
  • 实现了Deque接口，能当作双端队列使用。
  • 实现了Cloneable接口，覆盖了clone(),能克隆。
  • 实现了java.io.Serializable接口，这意味着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;
        }
    }

注：双向链表结构

构造方法

	//无参构造方法
	public LinkedList() {
    }

	/**
	* 有参构造方法，初始化，并集合c的元素添加到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) {
        //检查是否越界
        checkPositionIndex(index);
		//集合c转为数组
        Object[] a = c.toArray();
        int numNew = a.length;
        //如果集合c为空，则直接返回false
        if (numNew == 0)
            return false;
		//定义前置节点、待添加节点
        Node<E> pred, succ;
        //如果插入的位置等于链表的长度，就是将原集合元素附加到链表的末尾
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            //插入的不是末尾，先要找出插入的节点
            succ = node(index);
            pred = succ.prev;
        }
		//遍历要插入的元素
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            //如果pred==null，说明是插入的第一个元素
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }

        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }
		//大小增加
        size += numNew;
        modCount++;
        return true;
    }

	//检查index是否越界，越界则抛出异常
	private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
	private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

添加元素方法（双端队列）

    //添加元素，默认是添加到尾部
	public boolean add(E e) {
        linkLast(e);
        return true;
    }
	//添加元素到首部
    public void addFirst(E e) {
        linkFirst(e);
    }
	//添加元素到尾部
    public void addLast(E e) {
        linkLast(e);
    }

    // 作为无界队列，添加元素总是会成功的
    public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

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

    // 从队列首添加元素
    private void linkFirst(E e) {
        // 首节点
        final Node<E> f = first;
        // 创建新节点，新节点的next是首节点
        final Node<E> newNode = new Node<>(null, e, f);
        // 让新节点作为新的首节点
        first = newNode;
        // 判断是不是第一个添加的元素
        // 如果是就把last也置为新节点
        // 否则把原首节点的prev指针置为新节点
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        // 元素个数加1
        size++;
        // 修改次数加1，说明这是一个支持fail-fast的集合
        modCount++;
    }

    // 从队列尾添加元素
    void linkLast(E e) {
        // 队列尾节点
        final Node<E> l = last;
        // 创建新节点，新节点的prev是尾节点
        final Node<E> newNode = new Node<>(l, e, null);
        // 让新节点成为新的尾节点
        last = newNode;
        // 判断是不是第一个添加的元素
        // 如果是就把first也置为新节点
        // 否则把原尾节点的next指针置为新节点
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        // 元素个数加1
        size++;
        // 修改次数加1
        modCount++;
    }

注：在队列首尾添加元素很高效，时间复杂度为O(1)。

添加元素方法（List）

    // 在指定index位置处添加元素
    public void add(int index, E element) {
        // 判断是否越界
        checkPositionIndex(index);
        // 如果index是在队列尾节点之后的一个位置
        // 把新节点直接添加到尾节点之后
        // 否则调用linkBefore()方法在中间添加节点
        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

	// 在节点succ之前添加元素
    void linkBefore(E e, Node<E> succ) {
        // succ是待添加节点的后继节点
        // 找到待添加节点的前置节点
        final Node<E> pred = succ.prev;
        // 在其前置节点和后继节点之间创建一个新节点
        final Node<E> newNode = new Node<>(pred, e, succ);
        // 修改后继节点的前置指针指向新节点
        succ.prev = newNode;
        // 判断前置节点是否为空
        // 如果为空，说明是第一个添加的元素，修改first指针
        // 否则修改前置节点的next为新节点
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        // 修改元素个数
        size++;
        // 修改次数加1
        modCount++;
    }

    // 寻找index位置的节点
    Node<E> node(int index) {
        // 因为是双链表
        // 所以根据index是在前半段还是后半段决定从前遍历还是从后遍历
        // 这样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;
        }
    }

注：在中间添加元素比较低效，首先要先找到插入位置的节点，再修改前后节点的指针，时间复杂度为O(n)。

修改元素方法

	//修改指定位置的元素
	public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }

	//寻找index位置的节点
    Node<E> node(int index) {
        // 因为是双链表
        // 所以根据index是在前半段还是后半段决定从前遍历还是从后遍历
        // 这样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，要支持删除指定位置的元素；

所以删除元素方法一共有三个方法，分别如下：

    // remove的时候如果没有元素抛出异常
    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

    // remove的时候如果没有元素抛出异常
    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

    // 删除首节点
    private E unlinkFirst(Node<E> f) {
        // 首节点的元素值
        final E element = f.item;
        // 首节点的next指针
        final Node<E> next = f.next;
        // 添加首节点的内容，帮助GC
        f.item = null;
        f.next = null; // help GC
        // 把首节点的next作为新的首节点
        first = next;
        // 如果只有一个元素，删除了，把last也置为空
        // 否则把next的前置指针置为空
        if (next == null)
            last = null;
        else
            next.prev = null;
        // 元素个数减1
        size--;
        // 修改次数加1
        modCount++;
        // 返回删除的元素
        return element;
    }

    // 删除尾节点
    private E unlinkLast(Node<E> l) {
        // 尾节点的元素值
        final E element = l.item;
        // 尾节点的前置指针
        final Node<E> prev = l.prev;
        // 清空尾节点的内容，帮助GC
        l.item = null;
        l.prev = null; // help GC
        // 让前置节点成为新的尾节点
        last = prev;
        // 如果只有一个元素，删除了把first置为空
        // 否则把前置节点的next置为空
        if (prev == null)
            first = null;
        else
            prev.next = null;
        // 元素个数减1
        size--;
        // 修改次数加1
        modCount++;
        // 返回删除的元素
        return element;
    }

    // 删除中间节点
    public E remove(int index) {
        // 检查是否越界
        checkElementIndex(index);
        // 删除指定index位置的节点
        return unlink(node(index));
    }

    // 删除指定节点x
    E unlink(Node<E> x) {
        // x的元素值
        final E element = x.item;
        // x的前置节点
        final Node<E> next = x.next;
        // x的后置节点
        final Node<E> prev = x.prev;

        // 如果前置节点为空
        // 说明是首节点，让first指向x的后置节点
        // 否则修改前置节点的next为x的后置节点
        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        // 如果后置节点为空
        // 说明是尾节点，让last指向x的前置节点
        // 否则修改后置节点的prev为x的前置节点
        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        // 清空x的元素值，协助GC
        x.item = null;
        // 元素个数减1
        size--;
        // 修改次数加1
        modCount++;
        // 返回删除的元素
        return element;
    }

    // poll的时候如果没有元素返回null
    public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
    // poll的时候如果没有元素返回null
    public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }

注：在队列首尾删除元素很高效，时间复杂度为O(1)；在中间删除元素比较低效，首先要找到删除位置的节点，再修改前后指针，时间复杂度为O(n)。

查找元素方法

  • 作为双端队列，查找元素有两种方式，一种是获取队列首的元素，一种是获取队列尾的元素；
  • 作为List，要支持指定位置查找元素；

所以查找元素一共有三个方法，分别如下：

	//获取队首的元素
	public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

	//获取队尾的元素
	public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }
	
	//获取指定位置的元素
	public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

索引元素方法

	//获取指定元素第一次出现的索引，索引到返回位置，如果列表不包含元素，则返回-1
	public int indexOf(Object o) {
        int index = 0;
        //如果查找的元素为null(LinkedList可以允许null值)
        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) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }

栈

  • LinkedList是双端队列，双端队列可以作为栈使用；
  • 栈的特性是LIFO(Last In First Out)，所以作为栈使用也很简单，添加删除元素都只操作队列首节点即可；
    public void push(E e) {
        addFirst(e);
    }

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

三、总结

  • LinkedList是一个以双链表实现的List；
  • LinkedList还是一个双端队列，具有队列、双端队列、栈的特性；
  • LinkedList在队列首尾添加、删除元素非常高效，时间复杂度为O(1)；
  • LinkedList在中间添加、删除元素比较低效，时间复杂度为O(n)；
  • LinkedList不支持随机访问，所以访问非队列首尾的元素比较低效；
  • LinkedList在功能上等于ArrayList + ArrayDeque；
wanmeilingdu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java集合系列之LinkedList源码分析
08-27
主要为大家详细介绍了Java集合系列之LinkedList源码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java源码系列：LinkedList的底层实现原理和特性
鲁迷那的专栏—坚持实践后再写出来！
08-16 561
开启快速了解 链表 、LinkedList的底层实现原理和特性之旅。。。
java LinkedList 源码分析（通俗易懂)
Cyan_RA9的博客
03-16 1632
java 集合篇章——LinkedList类内容分享。包含LinkedLIst类的底层实现和源码分析。
java集合-LinkedList源码详解
qq_52616972的博客
09-15 519
LinkedList是一种屋里存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点组成，结点可以在运行时动态生成，LinkedList中有两个指针，前指针和后指针，是一个双向链表； 链表的增删由于不需要移动底层数组数据，其底层是链表实现的，只需要修改链表节点指针，所以效率较高。
java源码之LinkedList
星坠竹空
04-04 421
LinkedList优点： 基于双向链表实现，增删改的效率很高 可以当队列来用 LinkedList缺点： 链表的遍历时间复杂度是O（n），所以随机读是非常慢的 LinkedList使用场景： LinkedList在生产中使用较ArrayList少很多，因为一般程序都是读多写少，LinkedList却更适合写多读少的情况。 LinkedList主要方法解析： add(E e):在双向链表尾部插入一个元素 生成指针l指向双向链表中的最后一个元素last 生成一个新的node节点，pre是last,next是
Java常用集合之LinkedList（深入源码）
m0_62609939的博客
03-24 429
Java常用集合之LinkedList（深入源码）
Java源码解析LinkedList
08-26
今天小编就为大家分享一篇关于Java源码解析LinkedList，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
Java 集合之LinkedList源码分析
01-20
Java API中提供了链表的Java实现—LinkedList下。LinkedList是通过节点的连接实现链表的数据结构，向linkedList中插入或删除元素的速度是特别快，而随机访问的速度相对较慢，这个是由于链表本身的性质造成的，在链表...
java LinkedList源码详解及实例
08-31
主要介绍了java LinkedList源码详解及实例的相关资料,需要的朋友可以参考下
Java LinkedList源码分析
01-20
　LinkedList 是一个常用的集合类，用于顺序存储元素。 LinkedList 经常和 ArrayList 一起被提及。大部分人应该都知道 ArrayList 内部采用数组保存元素，适合用于随机访问比较多的场景，而随机插入、删除等操作因为...
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 371
都是符合我们的预期的。
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 434
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1463
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 628
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 768
consul官网地址。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 233
待更新。
迭代器模式
LuckFairyLuckBaby的博客
04-23 557
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 723
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
埃氏筛选-判断素数
最新发布
qq_45706306的博客
04-27 78
筛选：从最小的质数2开始，将它的所有倍数标记为合数（非质数），即把 isshushu 数组中对应索引位置的值设置为 true。计数：在筛选过程中，每当遇到一个未被标记为合数的数（即 isshushu 数组中对应值为 false 的数），则它就是一个质数，增加质数计数器 count 的值。返回结果：当所有小于 n 的数都经过筛选后，返回质数计数器 count 的值，即小于 n 的质数数量。通过这种方式，代码能够高效地找出并计算给定范围内质数的数量，避免了逐一检查每个数是否为质数的低效方法。
java源码中的hashmap,hashtable,arraylist,linkedlist
09-15
答：hashmap、hashtable、arraylist和linkedlist都是Java源码中常用的数据结构。hashmap是一种散列表，它使用键值对来存储数据；hashtable是一种哈希表，它使用散列函数来存储数据；arraylist是一种动态数组，它可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值