一文详解LinkedList

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

文章目录

链表概念

  • 链表是一种线性存储结构，物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接实现。

特征

有序性、可以存储不同类型元素、查询效率低、插入删除效率高。
image.png
image.png
（1）链表两大区域
元素区域：存储数据元素
指针区域：存储链表下一个节点地址，（双向链表还需要多一个指针存储上一个节点地址）
（2）有序性
链表元素的顺序通过链表指针链接实现的
re：双向链表,通过当前节点的next获取下一个节点的，通过prev获取上一个节点。
（3）非连续存储
链表使用非连续性内存空间存储的，通过链表指针指向下一个节点地址方式实现线性。
（4）查询效率低
查询通过首节点开始，根据节点的指针地址寻找到下一个节点，直到获取到对应的节点（时间复杂度为O(N)）。
注意：（双向链表的首、尾节点查询速度非常快。时间复杂度为O(1)）。
（5）插入删除效率高
插入删除效率高，应为链表通过节点指针链接次序的，做插入删除时候无需对其他元素存储内存空间进行重新编排。（数组的尾部新增元素、或者元素很少数组的删除、新增、修改效率很高的）
image.png

java LinkedList

LinkedList 是jdk基于链表数据结构封装的一个类，LinkedList同时实现了List接口和Deque接口，也就是说它既可以看作一个顺序容器，又可以看作一个队列(Queue)，同时又可以看作一个栈(Stack)。

类图

image.png
LinkedList 实现接口
java.util.List
java.util.Deque
java.io.Serializable
java.lang.Cloneable
List：jdk抽象数组具备特征通用行为，定义了jdk中数组的基本操作。
主要操作：查找、新增、移除、替代、迭代遍历等
Deque：提供双端队列的功能，LinkedList 支持快速的在头尾添加元素和读取元素，所以很容易实现该特性。
Serializable：空接口，作为支持序列化的标志；在这里表示LinkedList支持序列化。
详细说明：https://www.jianshu.com/p/e554c787c286
Cloneable：空接口，作为支持克隆的标志（Object.clone()），在这里表示LinkedList支持克隆。
详细说明：https://www.zhihu.com/question/52490586/answer/130786763

LinkedList继承抽象类
java.util.AbstractSequentialList
AbstractSequentialList 提供了 List 接口的通用方法实现，大幅度的减少了实现迭代遍历相关操作的代码。例如说 iterator()、indexOf(Object o) 、get(int index)、add(int index)等方法。

属性

/**
 * 链表节点数
 */
transient int size = 0;
/**
 * 头节点
 */
transient Node<E> first;

/**
 * 尾节点
 */
transient Node<E> last;


/**
 * 节点
 *
 * @param <E> 元素泛型
 */
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;
    }

}

（1）transient int size ;
链表的节点数量。通过它进行计数，避免每次需要 linkedList 大小时，需要从头到尾的遍历。
（2）transient Node first; transient Node last;
初始化时，first、last指向null，链表没有节点；新增一个节点node1时，first和last同时指向node1；
链表已经新增多个节点，则fist指向首个节点，last则指向最后一个节点。
（3）Node ; E item; Node next; Node prev;
Node 内部静态类，抽象了链表节点信息；item存放元素信息，prev指向前一个节点，next指向后一个节点。
image.png

方法

主要解析双端链表常用方法。

构造方法

LinkedList()；
LinkedList(Collection<? extends E> c)；

 /**
     * Constructs an empty list.
     * 构建一个空的list
     */
    public LinkedList() {
    }

    /**
     * 构建一个指定元素集合的LinkedList
     * 入参集合不可以为空
     * 
     */
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }
新增方法

add(E e);
add(int index, E element)；
addAll(int index, Collection<? extends E> c)；

    /**
     * 链表新增元素
     *
     **/
    public boolean add(E e) {
        //添加末尾
        linkLast(e);
        return true;
    }

    /**
     * 链表末尾新增元素
     **/
    void linkLast(E e) {
        //记录原 last 节点
        final Node<E> l = last;
        //新建节点 l前节点、e新增元素、null后节点
        final Node<E> newNode = new Node<>(l, e, null);
        //last 指向新建节点
        last = newNode;
        //如果前节点l为null，则first指向新建节点，否则前节点l的next指向新建节点；
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        //增加链表大小
        size++;
        //增加数组修改次数
        modCount++;
    }

 /**
     * 插入单个元素到指定位置
     **/
    public void add(int index, E element) {
        // 校验不要超过范围
        checkPositionIndex(index);

        //如果刚好等于链表大小，直接添加到尾部即可
        if (index == size)
            linkLast(element);
        else
            //添加到第 index 的节点的前面
            linkBefore(element, node(index));
    }

/**
     * 链表指定下标新增元素集合
     *
     **/
    public boolean addAll(int index, Collection<? extends E> c) {

        // 校验不要超过范围
        checkPositionIndex(index);

        //集合转换为数组（入参集合不能为null）
        Object[] a = c.toArray();
        int numNew = a.length;
        //元素集合为空，无添加元素，直接返回 false 链表未变更
        if (numNew == 0)
            return false;

        //获得第 index 位置的节点 succ ，和其前一个节点 pred
        Node<E> pred, succ;
        //如果下标属于链表尾部，那说明插入队尾，所以 succ 为 null ，pred 为 last
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            //如果 index 小于链表大小，则 succ 是第 index 个节点，prev 是 succ 的前一个二节点
            succ = node(index);
            pred = succ.prev;
        }

        //遍历 a 数组，添加到 pred 的后面
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            // 如果 pred 为 null ，说明 first 也为 null ，则直接将 first 指向新节点
            if (pred == null)
                first = newNode;
            // pred 下一个指向新节点
            else
                pred.next = newNode;
            // 修改 pred 指向新节点
            pred = newNode;
        }

        //修改 succ 和 pred 的指向
        if (succ == null) {
            // 如果 succ 为 null ，说明插入队尾，则直接修改 last 指向最后一个 pred
            last = pred;
        } else {
            //如果 succ 非 null ，说明插入到 succ 的前面
            // prev 下一个指向 succ
            // succes 前一个指向 pred
            pred.next = succ;
            succ.prev = pred;
        }

        //增加链表大小
        size += numNew;
        //增加数组修改次数
        modCount++;
        return true;
    }

/**
     * 添加元素 e 到 succ 节点的前面
     **/
    void linkBefore(E e, LinkedList.Node<E> succ) {
        // assert succ != null;
        //获取succ前一个节点
        final LinkedList.Node<E> pred = succ.prev;
        //新建e元素节点
        final LinkedList.Node<E> newNode = new LinkedList.Node<>(pred, e, succ);
        //设置 succ 的前一个节点为新节点
        succ.prev = newNode;
        // 如果 pred 为 null ，说明 first 也为空，则 first 也指向新节点
        if (pred == null)
            first = newNode;
        else
            // 如果 pred 非 null ，说明 first 也为空，则 pred 也指向新节点
            pred.next = newNode;
        // 增加链表大小
        size++;
        // 增加数组修改次数
        modCount++;
    }


    Node<E> node(int index) {
        // assert isElementIndex(index);

        // 如果 index 小于 size 的一半，就正序遍历，获得第 index 个节点
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
            // 如果 index 大于 size 的一半，就倒序遍历，获得第 index 个节点
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

add(int index, E element) 流程
image.png

删除方法

remove(int index)；
remove(Object o)；

    /**
     * 移除首个为 o 的元素
     **/
    public boolean remove(Object o) {
        // o 为 null 的情况
        if (o == null) {
            // 顺序遍历，找到 null 的元素后，进行移除
            for (LinkedList.Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            // 顺序遍历，找到等于 o 的元素后，进行移除
            for (LinkedList.Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 移除指定位置的元素
     **/
    public E remove(int index) {
        检查元素索引
        checkElementIndex(index);
        // 获得第 index 的 Node 节点，然后进行移除。
        return unlink(node(index));
    }

    E unlink(LinkedList.Node<E> x) {
        // assert x != null;
        //获取节点元素
        final E element = x.item;
        //获取节点后一个节点
        final LinkedList.Node<E> next = x.next;
        //获取节点前一个节点
        final LinkedList.Node<E> prev = x.prev;

        //如果前一个节点等于null，则表明删除的节点为首节点,first指向节点后一个节点
        if (prev == null) {
            first = next;
        } else {
            //如果前一个节点不等于null，则表明删除的节点不是首节点,节点的前一个节点的next指向节点的后一个节点
            prev.next = next;
            //节点prev指向null
            x.prev = null;
        }

        //如果后一个节点等于null，则表明删除的节点是尾节点,last指向节点前一个节点
        if (next == null) {
            last = prev;
        } else {
            //如果后一个节点不等于null，则表明删除的节点不是尾节点,节点的后一个节点的prev指向节点前一个节点
            next.prev = prev;
            //节点next指向null
            x.next = null;
        }

        //节点元素==null
        x.item = null;
        //减小链表大小
        size--;
        //增加数组修改次数
        modCount++;
        return element;
    }
获得指定位置的元素

E get(int index)；

    /**
     * 获取指定位置元素
     **/
    public E get(int index) {
        //验证节点是否存在
        checkElementIndex(index);
        //node(index) 获取节点
        return node(index).item;
    }

Node<E> node(int index) {
        // assert isElementIndex(index);

        // 如果 index 小于 size 的一半，就正序遍历，获得第 index 个节点
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
            // 如果 index 大于 size 的一半，就倒序遍历，获得第 index 个节点
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }
LinkedList实现Deque常用方法
public E peek() {
        final LinkedList.Node<E> f = first;
        return (f == null) ? null : f.item;
    }

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

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

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

常见面试题

1、ArrayList、LinkedList、Vector的区别是什么？
考察点分析：

ArrayList、LinkedList、Vector 3个类都继承了List接口，主要考察对基础知识的了解程度，方便在合适的场景使用不同的容器。

答案：
ArrayListLinkedListVector
底层结构数组双向链表数组
是否线程安全否否是
是否可以存null否否是
特点随机访问、查询快；在尾部添加效率高，其他地方插入慢插入、删除快；随机访问查询慢；用synchronized关键字，只能单线程进行查询等
2、LinkedList线程安全吗？
考察点分析：

考察对LinkedList源码理解

答案：

LinkedList线程不安全的。
re：LinkedList的添加元素展开进行分析
1.线程A找到last结点。
2.线程B找到last结点。（此时A、B找到的last结点是一样的）
3.线程A：新结点elementA的pre设为last结点，之前的last结点的next设为新结点elementA，last指向elementA。size+1=4
4.线程B:新结点elementB的pre设为last结点，之前的last结点的next设为新结点elementB，last指向elementB。size+1=5
image.png

3、简单实现双向链表
考察点分析：

考察对LinkedList源码理解，链表结构理解。

答案：

双向链表属性： 头指针、尾指针、容量
节点属性：前一个节点、节点元素、后一个节点
链表基本行为：新增、查找、删除

public class MyLinkedList<T> {

    private MyNode<T> first;
    private MyNode<T> last;
    private Integer size;

    public MyLinkedList() {
        size = 0;
    }

    public void add(T t){
        MyNode<T> tMyNode = new MyNode<>(t, last, null);
        if (this.last == null){
            first = tMyNode;
            last = tMyNode;
            return;
        }
        last.next = tMyNode;
        last = tMyNode;
        size++;
    }

    public void remove(Integer index){
        MyNode<T> myNode = Index(index);
        if (myNode.prev == null){
            first = myNode.next;
        }
        if (myNode.next == null){
            last = myNode.prev;
        }
        size--;
    }

    private MyNode<T> Index(Integer index){
        if (index<0 || index>=size){
            new Exception("");
        }
        MyNode<T> node = null;
        if (index < (size >> 1)){
            node =first;
            for(int i = size;index < i;i--){
                node = node.next;
            }
            return node;
        }
        node = last;
        for(int i = size-1;index > i;i--){
            node = node.prev;
        }

        return node;
    }

    public T get(Integer index){
        MyNode<T> myNode = Index(index);
        return myNode.element;
    }

    public static class MyNode<T> {
         T element;
         MyNode<T> prev;
         MyNode<T> next;
        public MyNode(T element, MyNode<T> prev, MyNode<T> next) {
            this.element = element;
            this.prev = prev;
            this.next = next;
        }
    }

    public Integer getSize() {
        return size;
    }

    public void setSize(Integer size) {
        this.size = size;
    }
}
4、你知道集合中的Fail-fast机制吗？为什么要有这样的机制？
考察点分析：

考察你对集合中的一些核心设计理念的了解。

答案：

fail-fast概念：快速失败系统，通常设计用于停止有缺陷的过程，这是一种理念，在进行系统设计时优先考虑异常情况，一旦发生异常，直接停止并上报。
我们通常说的Java中的fail-fast机制，默认指的是Java集合中的一种错误检测机制。

后端马农
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LinkedList详解
u010112268的博客
04-07 838
转载：https://blog.csdn.net/qedgbmwyz/article/details/80108618 一、源码解析1、 LinkedList类定义2、LinkedList数据结构原理3、私有属性4、构造方法5、元素添加add()及原理6、删除数据remove()7、数据获取get()8、数据复制clone()与toArray()9、遍历数据：Iterator()二、...
用LinkedList实现栈
JavaBOY
09-11 1709
栈的定义： 栈（Stack）是限制仅在一端进行插入和删除运算的线性表。 通常称插入和删除的这一端为栈顶，另一端为栈底。 当表中没有元素时称为空栈。 "栈"也被称为"后进先出"的容器。同其他Java容器一样，压进去与弹出来的东西都是Object，所以除非你只用Object的
LinkedList学习（基于JDK1.8）
lucyLee的博客
10-05 1117
1. 概述 LinkedList大多数时候被归类为List，但是更多的时候是被用于实现队列 本人就经常这样去定义一个队列，在有幸面试别人时，还问别人如何去new一个队列 Queue<Integer> queue = new LinkedList<>(); 因为，不懂为什么几乎能找到的资料都是这样定义队列的，希望面试者能给自己讲讲 ???? 面试别人是相互学习的过程 除此之外，自己还在学习LinkedList的过程中发现，相比直接使用Stack类实现栈，更建议通过
关于LinkedList
一切有为法，如梦亦如幻，如露亦如电，应作如是观。
09-25 2762
前言 LinkedList是一个实现了List接口和Deque接口的双端链表。 LinkedList底层的链表结构使它支持高效的插入和删除操作，另外它实现了Deque接口，使得LinkedList类也具有队列的特性。 LinkedList不是线程安全的，如果想使LinkedList变成线程安全的，可以调用静态类Collections类中的synchronizedList方法： List<Object> linkedList = Collections.synchronizedList
java LinkedList 怎么保证线程安全
最新发布
阿饱同学
06-28 471
在 Java 中，LinkedList本身并不是线程安全的。如果需要在多线程环境中使用LinkedList。
怎么看arraylist 和linklist是否线程安全
weixin_50659380的博客
04-14 1512
LinkedList也不是线程安全的，多个线程同时访问它时可能会导致并发问题，比如“写操作”和“读操作”同时进行时可能会导致数据不一致的问题。如果需要在多线程环境中安全地操作集合，可以使用线程安全的集合类，比如Vector或者CopyOnWriteArrayList，它们可以在多线程环境中安全地进行“写操作”和“读操作”。ArrayList不是线程安全的，多个线程同时访问它时可能会导致并发问题，比如“写操作”和“读操作”同时进行时可能会导致数据不一致的问题。
java中的LinkedList和ArrayList的选择和区别
ChenYiRan123456的博客
03-10 1203
对于LinkedList，如果是插在链表的头部或者是尾部都是很快的，因为LinkedList中有单独的属性记录的链表的头结点和尾结点，不过，如果是插在指定下标位置，那么就需要遍历链表找到指定位置，从而降低了效率。但是，使用LinkedList是不用担心扩容问题的，链表是不需要扩容的。虽然LinkedList是一个List集合，但是它的实现方式是通过一个动态的Object[]数组来实现的，而LinkedList的底层原理是通过链表来实现的，因此它的随机访问速度比较差，但是它的删除，插入操作会很快。
LinkedList线程不安全原理解析
weixin_43994631的博客
07-29 2336
今天复习java集合时，百度LinkedList为什么线程不安全，无果，于是自己去看了源码。就拿最简单的add()解释一下吧！第一次看源码，如有错误，希望大佬们指正！ 首先，我们需要知道的是，LinkedList中主要有3个属性，size（结点数），first（头结点），last（尾结点）。 其中结点Node的数据结构如下图： 好了，知道这些基础知识后，接下来的分析就会变得非常简单了。LinkedList的add方法其实只是引用了linkLast()这一个方法。...
java LinkedList的实例详解
08-29
"java LinkedList实例详解" Java LinkedList是一种基于链表的数据结构，在Java语言中广泛应用于实现队列、栈、双端队列等数据结构。下面将对Java LinkedList的实例进行详细的解释。 1. LinkedList类结构 Java ...
Java Linkedlist原理及实例详解
08-25
Java LinkedList原理及实例详解 Java LinkedList是Java集合框架中的一种数据结构，属于链表结构，方便添加和删除元素，但查询不方便，适用于对收尾的操作。下面将详细介绍Java LinkedList的原理及实例详解。 ...
Java集合框架LinkedList详解及实例
08-30
《Java集合框架LinkedList详解及实例》 在Java编程语言中，集合框架是处理对象集合的重要工具，而LinkedList是这个框架中的一个重要组成部分。LinkedList是一种双端链表，它不仅提供了列表的基本功能，还支持高效的...
Java中LinkedList详解和使用示例_动力节点Java学院整理
08-30
LinkedList是Java集合框架中的一种数据结构，它是List接口的一个实现，同时也实现了Deque接口，因此它不仅可以作为线性列表使用，还可以作为栈、队列或双端队列。下面我们将深入探讨LinkedList的特点、构造函数以及...
对ArrayList和LinkedList底层实现原理详解
08-26
ArrayList和LinkedList底层实现原理详解 ArrayList 底层实现方式的知识点： 1. ArrayList 底层实现方式：ArrayList 通过数组实现，一旦我们实例化 ArrayList 无参数构造函数默认为数组初始化长度为 10。 2. add ...
Hashtable和HashMap的区别及演示
weixin_44906436的博客
10-06 254
Hashtable和HashMap的区别 HashTable常用方法与HashMap一致 HashMap与Hashtable区别： 1、HashMap是线程不安全的，HashTable是线程安全的 2、HashMap中key可以为null，value也可以为null。HashTable不可以 3、Hashtable数组的初始容量是12，而HashMap是16 在实际开发中一般都是用HashMap。ConCurrentHashMap是线程安全的 public class HashTable
常用线程安全类型（ArrayList、LinkedList、CopyOnWriteArrayList、HashMap、LinkedHashMap、ConcurrentHashMap）
YimBa的博客
05-28 5301
常用线程安全类型（ArrayList、LinkedList、CopyOnWriteArrayList、HashMap、LinkedHashMap、ConcurrentHashMap）、线程安全
LinkedList的原理介绍
黑马程序员官方博客
03-11 586
一、LinkedList的概述 LinkedList是双向链表实现的List LinkedList是非线程安全的 LinkedList元素允许为null，允许重复元素 LinkedList是基于链表实现的，因此插入删除效率高，查找效率低（虽然有一个加速动作） LinkedList是基于链表实现的，因此不存在容量不足的问题，所以没有扩容的方法 LinkedList还实现了栈和队列的操作方...
为什么说ArrayList是线程不安全的？
放眼长期，稳中求进；知行合一，日拱一卒
03-23 2393
个人记录：2018年，工作的第6到7个年头。重点研究自己不太擅长的技术：分布式、高并发、大数据量、数据库优化、高性能、负载均衡等。刷题是一种态度，是一种好习惯。我刷题，我骄傲。把原来的例子，运行了下，增加了CopyOnWriteArrayList。package cn.fansunion.list;import java.util.ArrayList;import java.util.Collec...
【Java LinkedList详解】
Java程序员廖志伟
05-31 2570
Java中的LinkedList是一个重要的集合类，它是基于双向链表实现的，具有动态扩容能力、查询性能低、插入和删除性能高、访问和删除任意位置元素性能高以及线程安全等特点。本文将详细讲解LinkedList的实现原理、特性和使用场景。
LinkedList底层刨析
我姓谭却弹不死你的博客
07-25 172
● 底层原理：双向链表（动态数据结构）● 特点：①有序可重复(包含null 值)，可通过索引检索。②具有高效的插入和删除操作，但在随机访问时效率较低。③可以用作栈（stack）和队列（queue）这两种数据结构的底层实现或者使用线程安全的替代类：例如等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

后端马农

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值