LinkedList源码学习笔记

最新推荐文章于 2021-02-04 14:02:04 发布
最新推荐文章于 2021-02-04 14:02:04 发布
阅读量327 收藏
点赞数 1
分类专栏： java 文章标签： linkedlist linkedlist源码 jdk源码 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35835624/article/details/80203288
版权

LinkedList简介

LinkedList是一个实现了List接口和Deque接口的双端链表。
LinkedList除了可以当做链表来操作外，它还可以当做栈、队列和双端队列来使用。
LinkedList同样是非线程安全的，只在单线程下适合使用。
LinkedList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了Cloneable接口，能被克隆。

LinkedList的内部结构

linkedList是由一个个的节点Node组成，每个节点都包含上一个节点的引用、下一个节点的引用以及该节点引用的具体对象。节点对象Node的代码如下：

private static class Node<E> {
        //该节点引用的具体对象
        E item;
        //上一个节点的引用
        LinkedList.Node<E> next;
        //下一个节点的引用
        LinkedList.Node<E> prev;

        Node(LinkedList.Node<E> prev, E element, LinkedList.Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

节点的示意图如下：
node示意图

LinkedList的继承和实现结构

LinkedList的类图如下：
这里写图片描述
由上图可知，LinkedList继承了抽象类AbstractSequentialList并实现了List，Deque，Cloneable，Serializable接口。

LinkedList的成员变量

    //链表的长度
    transient int size = 0;
    //链表的第一个节点
    transient LinkedList.Node<E> first;
    //链表的最后一个节点
    transient LinkedList.Node<E> last;

LinkedList常见API的源码学习

1、boolean add(E e)

大致逻辑：添加新节点newNode到链表的末尾，将原先链表的最后一个节点last的next指向newNode，并将newNode的prev指向last。

public boolean add(E e) {
    linkLast(e);
    //该方法永远都返回True
    return true;
}
//向链表的最后一位添加节点
void linkLast(E e) {
    final LinkedList.Node<E> l = last;
    //调用Node的构造器来创建一个新的节点
    // 第一个参数为该新节点的上一个节点，第二个参数为当前节点引用的对象
    //第三个参数为该新节点的下一个节点
    final LinkedList.Node<E> newNode = new LinkedList.Node<>(l, e, null);
    last = newNode;
    if (l == null)
        //l == null即链表的长度为0，该新增的节点是第一个节点
        first = newNode;
    else
        l.next = newNode;
    //链表长度+1
    size++;
    modCount++;
}

2、void add(int index, E element)

public void add(int index, E element) {
        //检查索引index的大小是否超出LinkedList的size。
        checkPositionIndex(index);
        //判断是否是临界值
        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }
    //先将查找的范围缩小一半，然后再通过遍历去获取指定索引处的节点
    //当指定的索引小于size/2时，则进行正向的遍历查找
    //当指定的索引大于size/2时，则进行逆向的遍历查找
    LinkedList.Node<E> node(int index) {
        if (index < (size >> 1)) {
            LinkedList.Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            LinkedList.Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

    // e为要插入的节点的对象引用，succ为指定索引处的节点
    void linkBefore(E e, LinkedList.Node<E> succ) {
        //获取index处的节点succ的上一个节点pred
        final LinkedList.Node<E> pred = succ.prev;
        //创建一个新的节点newNode，newNode的上一个节点为pred，下一个节点为succ
        final LinkedList.Node<E> newNode = new LinkedList.Node<>(pred, e, succ);
        //将succ的上一个节点指向newNode
        succ.prev = newNode;
        //pred的下一个节点指向newNode
        if (pred == null)
            //处理临界情况
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

大致过程如下图所示：
这里写图片描述

3、void addLast(E e）和 void addFirst(E e)

见名知意，addLast(E e)调用的是linkedLast(E e)方法,同boolean add(E e)方法调用的同一个方法。

两者的区别:
1、两个方法的返回值不同，一个是无返回值，另一个永远都返回true。
2、无返回值的是重写抽象类AbstractSequentialList中的add方法，而有返回值的是实现的Deque接口的方法。

void addFirst(E e)方法方用的是void linkFirst(E 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++;
    }

可以看到该方法和void linkLast(E e)方法的实现思路相同，只是一个是向链表的头处添加节点，一个是向链表的末尾添加节点。

4、boolean addAll(Collection c)和boolean addAll(int index, Collection c)

boolean addAll(int index,Collection c)方法的实现思路同void add(int index, E element)方法相似，只是要添加的是一个集合，所以多了一步遍历集合插入的步骤。

//向链表的末尾添加一个集合
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

    //参数：index为要向链表插入的索引；c：为将要添加的集合
    public boolean addAll(int index, Collection<? extends E> c) {
        //检查索引是否超出链表的长度
        checkPositionIndex(index);

        Object[] a = c.toArray();
        //numNew为将要添加的节点的个数
        int numNew = a.length;
        if (numNew == 0)
            return false;

        //pred为上一个节点，succ为当前节点
        LinkedList.Node<E> pred, succ;

        if (index == size) {
            succ = null;
            pred = last;
        } else {
            succ = node(index);
            pred = succ.prev;
        }

        //遍历集合c，向链表插入新的节点
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            LinkedList.Node<E> newNode = new LinkedList.Node<>(pred, e, 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;
    }

5、E remove() && E removeFirst()

E remove()方法和E removeFirst()方法的作用都是删除链表的第一个节点，返回被删除的节点。代码如下：

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

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

//参数f为当前链表的第一个节点
//大致逻辑：获取第一个节点，并将第一个节点的item和next置为null。再将第二个节点的prev置为null。
private E unlinkFirst(LinkedList.Node<E> f) {
    //获取第一个节点f中的对象引用
    final E element = f.item;
    final LinkedList.Node<E> next = f.next;
    f.item = null;
    f.next = null;
    first = next;
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}

6、boolean remove(Object o) && boolean removeFirstOccurrence(Object o)

该方法为删除链表中指定的对象，返回值为boolean类型。
删除指定对象的大致过程如下：
这里写图片描述

相关代码如下：

public boolean removeFirstOccurrence(Object o) {
         return remove(o);
}
public boolean remove(Object o) {
        //先在链表中找到需要删除的元素，然后再调用unlink方法进行删除
        if (o == null) {
            for (LinkedList.Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                 }
            }
        } else {
            for (LinkedList.Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
}
E unlink(LinkedList.Node<E> x) {

     final E element = x.item;
     final LinkedList.Node<E> next = x.next;
     final LinkedList.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;
}

7、E remove(int index)

删除指定索引处的节点

 public E remove(int index) {
        checkElementIndex(index);
        //先获取到执行索引处的节点元素，然后再调用unlink(E e)方法进行删除
        return unlink(node(index));
 }

8、E removeLast()

移除链表的最后一个节点，逻辑同上。

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

    private E unlinkLast(LinkedList.Node<E> l) {
        final E element = l.item;
        final LinkedList.Node<E> prev = l.prev;
        l.item = null;
        l.prev = null; 
        last = prev;
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

9、boolean contains(Object o)

判断链表中是否包含某个对象

public boolean contains(Object o) {
        return indexOf(o) != -1;
}

10、E element() && E getFirst()

public E element() {
    //获取第一个节点中的对象
    return getFirst();
}
public E getFirst() {
   final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}

11、E get(int index)

获取指定索引处的节点的对象

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

12、E getLast()

逻辑与E element() && E getFirst()相似

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

13、int indexOf(Object o) && lastIndexOf(Object o）

int indexOf(Object o)：正向查找，获取链表中第一个指定对象的索引，如果没有则返回-1。
lastIndexOf(Object o):反向查找，其余逻辑同int indexOf(Object o)相同。

//从first节点开始遍历，直到找到指定对象
    public int indexOf(Object o) {
        int index = 0;
        if (o == null) {
            for (LinkedList.Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
            for (LinkedList.Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }

14、boolean offer(E e) && boolean offerFirst(E e) && boolean offerLast(E e)

boolean offer(E e)：向链表的末尾添加元素，调用add(E e)方法。
boolean offerFirst(E e)：向链表的首部添加元素，调用addFitst(E e)方法。
boolean offerLast(E e)：向链表的末尾添加元素，调用addLast(E e)方法。

public boolean offer(E e) {
    return add(e);
}
public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}
public boolean offerLast(E e) {
    addLast(e);
    return true;
}

15、E peek() && E peekFirst() && E peekLast()

//当链表不为空时，返回链表的第一个元素
public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
}
//当链表不为空时，返回链表的第一个元素
public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
}
//当链表不为空时，返回链表的最后一个元素
public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
}

16、E poll() && E pollFirst() && E pollLast()

//当链表不为空时，返回链表的第一个元素,并删除第一个元素
public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
}
//当链表不为空时，返回链表的第一个元素,并删除第一个元素
public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
}
//当链表不为空时，返回链表的第一个元素,并删除最后一个元素
public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
}

17、E pop()

//删除链表的第一个元素，并返回被删除的元素
public E pop() {
        return removeFirst();
}
A股慈善家
关注
专栏目录
linked list 链表详解 源程序
02-26
在linux环境下已测试，放心使用，这个是根据stanford cs library的linked list文章里的代码敲出来的
Java LinkedList学习笔记
DerWeltraum
01-05 2449
最近在学习Java基础知识，LinkedList是Java的一种常见的数据类型，所以我准备针对它做一个笔记，以供自己查阅。
【Java集合源码剖析】LinkedList源码剖析
ZWF564267707的博客
12-23 113
转载请注明出处：http://blog.csdn.net/ns_code/article/details/35787253 您好，我正在参加CSDN博文大赛，如果您喜欢我的文章，希望您能帮我投一票，谢谢！ 投票地址：http://vote.blog.csdn.net/Article/Details?articleid=35568011 LinkedList简介 ...
LinkedList作为队列添加删除数据位置的总结
woslx的博客
02-26 2063
LinkedList作为队列添加删除数据位置的总结 LinkedList是使用链表实现的List，并且它是双向List。List中的数据通过引用有顺序地排列。ArrayList把数据保存在数组中，而LinkedList的数据保存在Node中，通过Node中的指向其他Node的引用，串成一个List。Node的结构： private static class Node<E> { ...
单向链表的尾部添加节点，展示结点
有时间可以指导毕业设计，可以私聊我。一个热爱编程的smallCuteMonkey，可以私信我
02-04 864
package com.demo.Link; import java.util.Scanner; public class SingleLinkList { public static void main(String[] args) { //进行测试 HeroNode heroNode = new HeroNode( 1, "houzhicong", "chxuyuan" ); HeroNode heroNode1 = new HeroNode( 2, "
基于Java的网课学习笔记设计源码
最新发布
05-31
本项目名为"基于Java的网课学习笔记设计源码"，是一个使用Java语言开发的高效学习笔记管理系统。这个系统的设计目标是为用户创造一个便捷、高效的在线学习环境，帮助他们更好地整理、记录和管理自己的学习笔记。以下...
非常详细javaSE学习笔记.rar
10-21
这份“非常详细JavaSE学习笔记.rar”压缩包显然是一份全面的Java SE学习资源，包含了从基础知识到高级特性的全方位讲解。下面，我们将详细探讨这份笔记可能涵盖的关键知识点。 1. **Java起源与环境搭建**：笔记可能...
C#编程学习笔记_C#编程学习笔记_
10-02
5. **集合与泛型（Collections and Generics）**：了解ArrayList、LinkedList、Dictionary、HashSet等集合类型，以及泛型的概念，能够帮助你有效地存储和操作数据。 6. **LINQ（Language Integrated Query）**：C#...
Java学习笔记（源码）
11-11
【Java学习笔记（源码）】是一份详细记录了Java编程语言学习过程的资源集合，包含实际的源代码示例。这份笔记旨在帮助初学者和有一定经验的开发者深入理解和掌握Java语言的核心概念、语法以及常见应用。以下是笔记中...
Java学习笔记加源码
03-15
"Java学习笔记加源码"的资源集合，显然是为了帮助初学者或有经验的开发者深入理解Java编程，并通过源代码实践来提升技能。 1. **Java基础知识**：Java的基础包括语法、数据类型、控制结构（如if语句、for循环、...
编写一个应用程序，要求将LinkedList创建的对象写入文件，在读出一个LinkedList节点中的数据。
The_star_is_at的博客
05-15 4372
编写一个应用程序，要求将LinkedList创建的对象写入文件，在读出一个LinkedList节点中的数据。 import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;
记录工作中遇到的k8s的坑
qq_39904356的博客
07-24 438
记录工作中遇到的k8s的坑和简单用法1、k8s指定node节点启动pod 1、k8s指定node节点启动pod 在工作中遇到集群节点通信问题，需要指定节点启动pod的情况，这个时候就要去修改yaml脚本。 首先我需要知道指定节点上的标签，k8s不能直接指定hostname进行节点指定，需要从节点的label中找到特征的key-value，用 nodeSelector 这个字段，放在containers的同级。不要用TAB键。 执行下面这条命令 kubectl get node --show-la
Java LinkedList void add（int index，Object o）方法，带示例
cumudi0723的博客
06-22 646
LinkedList void add(int index，Object o)方法 (LinkedList void add(int index, Object o) method) This method is available in package java.util.Collection and here, Collection is an interface. 该方法在java.uti...
程序员必会系列之——手写“双向链表”
first_M的博客
05-26 285
先赞再看，养成习惯！ 链表作为一种常用的数据结构，我们还是有必要了解一下的，如果有不太了解什么是“链表”的可以查看一下之前的文章。今天让我们动手实现一个“双向链表”。 双向链表的节点类 public class Node { /** * 数据域 */ public String data; /** * 指针域（指向下一个节点） */ public Node next; /** * 指针域（指向前一个节点） */ public Node pr
java8中的default关键字
热门推荐
我是兴锅的博客
05-05 10万+
在学习集合代码时发现在Iterable接口中使用了default关键字。 default关键字介绍 default是在java8中引入的关键字，也可称为Virtual extension methods——虚拟扩展方法。是指，在接口内部包含了一些默认的方法实现（也就是接口中可以包含方法体，这打破了Java之前版本对接口的语法限制），从而使得接口在进行扩展的时候，不会破坏与接口相关的实现...
一个实用的数据库和redis的心跳检测工具类
我是兴锅的博客
03-03 2562
先贴代码，然后再演示，代码非常简单。代码public class TestHeartBeat { public static void main(String[] args) throws Exception { databaseHeartBeatCheck(); redisHeartBeatCheck(); } //测试数据库 publ
实现一个简单的单向链表
我是兴锅的博客
10-09 1810
什么是单向链表 单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点 单向链表的结构图 代码 因为实现比较简单所以不做过多解释，该实现未实现Iterable接口，也未做并发修改异常的检测。 public class...
使用栈来实现字符串符号平衡的检测
我是兴锅的博客
10-09 1384
什么是联机算法？ 联机算法是在任意时刻算法对要操作的数据只读入（扫描）一次，一旦被读入并处理，它就不需要在被记忆了。而在此处理过程中算法能对它已经读入的数据立即给出相应子序列问题的正确答案。 该算法仅需要常量空间并以线性时间运行，因此联机算法几乎是完美的算法。 优点 占用空间少，所用时间少 缺点 不宜设计，正确性不易观察，同时附加保留信息较少 什么是平衡符号？ 所谓平衡符号就是说，每...
递归判断对象或集合是否全为空的工具
我是兴锅的博客
09-29 874
说明 1、代码依赖了hutool的相关API，如果不想依赖hutool的话可以用阿帕奇或者spring的相关API进行替换。 2、对于是否为空的标准在代码里是写死的，详见注释。 代码实现 工具类的代码如下： /** * {@link #isDeepEmpty(Object object, Boolean ignoreBoolean)}的重载方法，ignoreBoolean参数为false * * @param object 要判断的对象 * @return object的所有属性是否都为空 */
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值