LinkedList详解

已于 2022-05-18 13:33:52 修改
阅读量1k 收藏 5
点赞数 1
分类专栏： java集合 文章标签： 链表 java 数据结构
于 2022-01-18 16:30:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39093474/article/details/122553273
版权

LinkedList

文章目录

1. 简介

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

LinkedList是List接口的实现类，继承了AbstractSequentialList，并实现了List，Deque和Cloneable接口。它是一个集合，可以根据索引来随机访问集合中的元素，也因为实现了Deque接口，他还是一个队列，可以被当成双端队列使用，虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，ArrayList的底层是通过一个动态的Object[]数组来实现的，LinkedList的底层是通过链表来实现的，因此他的随机访问效率差，但是添加，删除效率高。
总结一下：

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

2. 成员变量

  transient int size = 0;//LinkedList中存放的元素个数
  transient Node<E> first;//头节点
  transient Node<E> last;//尾节点

大家看到Node这个类型可能不太懂是什么意思，其实这是Linked自己封装的一个内部类，相当于链表中的一个节点。

//静态内部类，创建节点
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. 单向链表

单向链表就是通过每个节点的指针指向下一个节点从而链接起来的结构，最后一个节点的next指向null。

在这里插入图片描述

2. 单向循环链表

单向循环链表和单向列表的不同是，最后一个节点的next不是指向null，而是指向head节点，形成一个“环”。

在这里插入图片描述

3. 双向链表

从名字就可以看出，双向链表是包含两个指针的，pre指向前一个节点，next指向后一个节点，但是第一个节点head的pre指向null，最后一个节点的tail指向null。而LinkedList就是基于双向链表设计的。
在这里插入图片描述

4. 双向循环链表

双向循环链表和双向链表的不同在于，第一个节点的pre指向最后一个节点，最后一个节点的next指向第一个节点，也形成一个“环”。
在这里插入图片描述

总结：
LinkedList是通过双向链表来实现的，既然是链表那么随机访问的效率比ArrayList低，但是添加和删除的效率比ArrayList高（ArrayList尾部添加元素的效率和LinkedList差不多），大家还需要了解两个概念，不然看源码大家可能会有点迷惑。

  • 前驱（prev）：每一个节点都有前驱，指向前面节点的指针
  • 后继（next）：每一个节点都有后继，指向后面节点的指针
  • 元素或者值（item）：就是每个节点存储的元素。
    在这里插入图片描述

3. 构造函数

	//构造方法，创建一个空的列表
	public LinkedList() {}
	//将一个指定的集合添加到LinkedList中，先完成初始化，在调用添加操作
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

可以从LinkedList提供的两个构造函数看出没有长度这个概念，所以不存在容量不足的情况（前提条件是内存足够），因此不需要判断超出长度，使用扩容方法。

//将集合中的元素添加到List中
 public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }
     //将集合中的元素全部插入到LinkedList中，并从指定的位置开始
       public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);//检测索引是否合法
        Object[] a = c.toArray();//将Collection集合转化为数组
        int numNew = a.length;//数组长度
        if (numNew == 0)//集合中没有元素，返回false
            return false;

        Node<E> pred, succ;//pred 前驱节点  succ：当前节点
        if (index == size) {//判断此时是集合最后元素
            succ = null;//当前节点为null
            pred = last;//前驱节点是尾节点
        } else {
            succ = node(index);//获取位置为index的结点元素，并赋值给succ
            pred = succ.prev;//succ 节点的前驱节点
        }
		//遍历数组进行插入操作。修改节点的前驱后继
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null)
                first = newNode;//如果前驱节点为null，变为头节点
            else
                pred.next = newNode;//后驱节点指向新增的节点
            pred = newNode;//把newNode变为前驱节点，继续追加
        }

        if (succ == null) {
            last = pred;//最后的newNode变为尾节点
        } else {
            pred.next = succ;//数组最后的节点后继指向添加前的节点
            succ.prev = pred;//添加前的节点前驱指向数组最后的节点
        }

        size += numNew;
        modCount++;
        return true;
    }

4. 常用方法解析

4.1 add操作

//在LinkedList的尾部添加元素
public boolean add(E e) {
     linkLast(e);
     return true;
}
//插入尾节点
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++;
}

LinkedList添加元素默认是添加到LinkedList的尾部，首先将last节点赋值给I节点，然后新建节点newNode ，并把前驱指向I节点，data = e , next = null , 并将新节点赋值给last节点，它成为了最后一个节点，根据当前List是否为空做出相应的操作。若不为空将l的后继指针修改为newNodw。 size +1 , modCount＋１

//在指定索引添加元素
 public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }
    //在succ节点前插入e节点，并修改各个节点之间的前驱后继
     void linkBefore(E e, Node<E> succ) {
        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 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++;
    }

从源码中可以看到，LinkedList不仅提供了linkLast(E e)（插入尾节点）的方法还提供了linkFirst(E e)（插入头节点）和add(int index, E element)（指定位置节点的方法），实现了双端操作。

4.2 remove操作

	//删除指定索引的元素
	public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }
  //删除值为o的元素
  public boolean remove(Object o) {
        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) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
    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;
    }

无论是删除指定索引索引的元素还是值为o的元素，底层都是调用 unlink(Node<E> x) 方法。remove(Object o) 先循环遍历列表，找到item == o 的节点，在调用unlink()方法删除。而删除指定索引的元素可以直接找到o节点，然后删除。

4.3 set操作和get操作

//将节点放置在指定的位置
 public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }
    //返回指定元素的值
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
    /**
    返回指定位置的节点信息
    LinkedList无法随机访问，只能通过遍历的方式找到相应的节点
    为了提高效率，当前位置首先和元素数量的中间位置开始判断，小于中间位置，
    从头节点开始遍历，大于中间位置从尾节点开始遍历
    */
    
    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;
        }
    }

因为LinkedList无法随机访问，只能通过遍历查找元素，虽然通过加速，只要查找一半的集合。找到指定的元素然后修改其值。

4.4 clear操作

  public void clear() {
 //遍历集合中元素，然后置为null。
        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++;
    }

5. 总结

  • LinkedList是一个功能很强大的类，可以被当作List集合，双端队列和栈来使用。
  • LinkedList底层使用链表来保存集合中的元素，因此随机访问的性能较差，但是插入删除时性能非常的出色。
  • ArrayList，底层采用数组实现，如果需要遍历集合元素，应该使用随机访问的方式，对于LinkedList集合应该采用迭代器的方式。
  • 如果需要经常的插入。删除操作可以考虑使用LinkedList集合
    如果有多个线程需要同时访问List集合中的元素，开发者可以考虑使用Collections将集合包装成线程安全的集合。

6. 栈和队列的源码分析

    //弹出第一个元素的值
    public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }
    //获取第一个元素
    public E element() {
        return getFirst();
    }
    //弹出第一元素，并删除
    public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
    //删除第一个元素
    public E remove() {
        return removeFirst();
    }
    //添加到尾部
    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;
    }
    //队列操作
    //尝试弹出第一个元素，但是不删除元素
    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;
    }
    //弹出第一个元素，并删除
    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);
    }
    //如队列，添加到头部
    public void push(E e) {
        addFirst(e);
    }
    //出队列删除第一个节点
    public E pop() {
        return removeFirst();
    }
 
   //删除指定元素第一次出现的位置
    public boolean removeFirstOccurrence(Object o) {
        return remove(o);
    }
qq_39093474
关注
专栏目录
Linkedlist详解
q306507291的博客
07-17 473
1.1概述 Linkedlist详解 LinkedList 是 Java 集合中比较常用的数据结构，与 ArrayList 一样，实现了 List 接口，诸如add,remove,contains等等方法，只不过 ArrayList 是基于数组实现的，而 LinkedList 是基于链表实现的。所以 LinkedList 插入和删除方面要优于 ArrayList，而随机访问上则 ArrayList 性能更好。 除了 LIst 接口之外，LinkedList 还实...
集合框架源码学习之LinkedList
weixin_34138056的博客
03-19 181
0-1. 简介 0-2. 内部结构分析 0-3. LinkedList源码分析   0-3-1. 构造方法   0-3-2. 添加add方法   0-3-3. 根据位置取数据的方法   0-3-4. 根据对象得到索引的方法   0-3-5. 检查链表是否包含某对象的方法   0-3-6. 删除removepop方法 0-4. LinkedList类常用方法 简介 LinkedList是一个实现了...
【数据结构】链表之LinkedList（无头双链表实现 + 详解 + 原码）
最新发布
明志の博客
07-26 1125
LinkedList是无头双向非循环链表学习链表的知识一定要 结合图，多画图，才能深刻理解LinkedList官方文档LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。在集合框架中， LinkedList也实现了List接口。
Java04——LinkedList详细介绍(源码解析)和使用示例
JasonChen3318的博客
08-30 238
一、LinkedList介绍 LinkedList是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList实现List接口，能对它进行队列操作。 LinkedList实现Deque接口，即能将LinkedList当作双端队列使用。 LinkedList实现了Cloneable接口，即覆盖了函数clo...
LinkedList简介
it_yangkun的博客
10-05 321
LinkedList简介 LinkedList是基于双向循环链表（从源码中可以很容易看出）实现的，除了可以当作链表来操作外，它还可以当作栈，队列和双端队列来使用。 LinkedList同样是非线程安全的，只在单线程下适合使用。 LinkedList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了Cloneable接口，能被克隆。 Linked
详解LinkedList
weixin_47382783的博客
07-24 1809
linkedList本质上是一个双向链表，通过一个Node内部类实现的这种链表结构。LinkedList能存储null值。LinkedList在删除和增加等操作上性能好，而ArrayList在查询的性能上好。从源码中看，它不存在容量不足的情况。LinkedList不光能够向前迭代，还能像后迭代，并且在迭代的过程中，可以修改值、添加值、还能移除值。LinkedList不光能当链表，还能当队列使用，这个就是因为实现了Deque接口。...
Java集合框架LinkedList详解及实例
08-30
《Java集合框架LinkedList详解及实例》 在Java编程语言中，集合框架是处理对象集合的重要工具，而LinkedList是这个框架中的一个重要组成部分。LinkedList是一种双端链表，它不仅提供了列表的基本功能，还支持高效的...
ArrayList和LinkedList详解
JSDHBIV的博客
06-13 260
ArrayList和LinkedList详解（基于jdk1.8）ArrayList集合ArrayList源码解析继承关系属性构造方法默认值扩容机制常用方法LinkedList集合LinkedList源码剖析继承关系属性构造方法默认值扩容机制常用方法ArrayList和LinkedList的区别应用场景 ArrayList集合 ArrayListList实现自AbstractList抽象类，是基于数组实现List接口的实现类。 特点：可以存储重复的数据，存入的数据是有序的（插入有序），可以存储NULL值。 A
Java中LinkedList详解和使用示例_动力节点Java学院整理
08-30
LinkedList是Java集合框架中的一种数据结构，它是List接口的一个实现，同时也实现了Deque接口，因此它不仅可以作为线性列表使用，还可以作为栈、队列或双端队列。下面我们将深入探讨LinkedList的特点、构造函数以及...
java集合 collection-list-LinkedList详解
08-31
`LinkedList`类是实现`List`接口的一个具体类，它提供了链表结构的数据存储方式，允许在列表的任何位置进行插入和删除操作，而不需要移动其他元素。 `LinkedList`的主要特点包括： 1. **内部结构**：`LinkedList`...
LinkedList详解和使用示例_动力节点Java学院整理
10-26
LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList 实现 List 接口，能对它进行队列操作。 LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
LinkedList 详解
Same_Liu的博客
03-29 429
（注：本文内容基于JDK1.6） 一、LinkedList概述： LinkedList与ArrayList一样实现List接口，只是ArrayList是List接口的大小可变数组的实现，LinkedList是List接口链表的实现。 基于链表实现的方式使得LinkedList在插入和删除时更优于ArrayList，而随机访问则比ArrayList逊色些。 LinkedList实现所有可选的列表操作...
LinkedList详解(含数据结构动画演示)
落日的博客
06-07 1293
/ 获取链表的最后一个节点，赋值给变量 l// 如果链表为空，即最后一个节点为 null，抛出 NoSuchElementException 异常// 调用 unlinkLast 方法，从链表中移除最后一个节点// 确保 l 是最后一个节点且不为 null 的断言，注释掉的是因为在实际代码中没有执行断言检查的需要= null;// 保存最后一个节点的值// 保存最后一个节点的前一个节点// 将最后一个节点的值设为 null，帮助垃圾回收。
linkedlist详解
03-30
链表是一种数据结构，它由一系列节点组成，每个节点包含一个数据元素和指向下一个节点的指针。链表的特点是可以动态地添加或删除节点，而不需移动其他节点的位置。 链表可以分为单向链表、双向链表和循环链表三种。单向链表每个节点只有一个指针指向下一个节点，双向链表每个节点有两个指针，分别指向前一个节点和后一个节点，循环链表的尾节点指针指向头节点。 链表的优点是可以动态地添加或删除节点，但其缺点是访问节点时需要遍历链表，因此访问效率较慢。 在实现链表时，需要定义节点类，包含数据元素和指向下一个节点的指针。同时还需要定义链表类，包含头节点指针和尾节点指针，以及添加、删除、查找节点等操作方法。在链表的实现中，需要注意处理边界情况和空链表的情况。 链表的应用非常广泛，例如在实现堆栈、队列、哈希表等数据结构时都可以使用链表。在操作系统中，进程控制块也可以使用链表来实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值