【Java 集合】LinkedList

已于 2023-12-16 00:30:32 修改
阅读量1.2k 收藏 16
点赞数 22
分类专栏： # Java 集合 文章标签： Java Java 集合
于 2023-11-26 16:58:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LCN29/article/details/134629882
版权

LinkedList 一个双向链表。
本身是基于链表进行封装的列表, 所以具备了链表的特性: 变更简单, 容量是无限的, 不必像数组提前声明容量等。
同时 LinkedList 支持存储包括 null 在内的所有数据类型。

1 链表

了解 LinkedList 之前, 我们需要先了解一下双向链的特点

  1. 单链表, 双链表, 循环链表的定义, 可以看一下这个
  2. 链表内存是散乱的, 每一个元素存储本身内存地址的同时还存储下一个元素的地址
  3. 链表具备了增删快, 查找慢的特点
  4. LinkedList 是基于双向链表设计的, 所以具备了链表的特点

2 LinkedList 中每个节点的定义

private static class Node<E> {

  	/** 当前节点的内容 */
    E item;

    /** 下一个节点 */
    Node<E> next;

    /** 上一个节点 */
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        // 当前节点的数据 = element
        this.item = element;
        // 当前节点的后置节点 = next
        this.next = next;
        // 当前节点的前置节点 = prev
        this.prev = prev;
    }
}

Node 节点中除了指向下一个节点的 next, 还包含指向上一个节点的 prev, 所以 LinkedList 是一个双向的链表。

3 LinkedList 中的几个属性

public LinkedList<E> {

    transient int size = 0;

    transient Node<E> first;

    transient Node<E> last;
}

3.1 size

表示当前链表中的节点个数。

3.2 first

整个双向链表的头节点

3.3 last

整个双向链表的尾节点

重要的就这个几个属性了

4 LinkedList 的构造方法

public LinkedList<E> {

    // 构造函数 1: 无参构造函数
    public LinkedList() {
    }

    // 构造函数 2: 给定一个 Collection 的构造
    public LinkedList(Collection<? extends E> c) {
        // 省略
    }
}

4.1 无参的构造函数

public LinkedList() {
}

就是单纯的声明 LinkedList 的实例, 没有其他的逻辑了

4.2 给定一个 Collection 的构造

public LinkedList(Collection<? extends E> c) {

    // 调用自身无参的构造函数
    this();

    // 将集合 c 添加到当前的链表中
    addAll(c);
}

/**
 * 将集合对象全部添加到当前链表中
 */
public boolean addAll(Collection<? extends E> c) {
    // 调用 addAll 重写方法在 size 的位置添加数据
    return addAll(size, c);
}

/**
 * 指定位置的批量插入
 */
public boolean addAll(int index, Collection<? extends E> c) {

    // 判断 0 <= index <= size, 不满足抛出异常
    checkPositionIndex(index);

    // 集合转为数组
    Object[] a = c.toArray();
    int numNew = a.length;

    // 需要插入的集合没有数据, 直接结束
    if (numNew == 0)
        return false;

    // pred: 新增的元素的将要插入的位置的前一个节点  
    // succ: 新增的元素的将要插入的位置的节点
    // 如果新增的元素的节点位置为 a, 那么 pred 就是 a 的前一位的节点, succ 就是 a 节点
    Node<E> pred, succ;
    
    // 需要添加的元素刚好追加在已有的后面的
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        // 获取指定位置的节点
        succ = node(index);
        pred = succ.prev;
    }    

    for (Object o : a) {

        E e = (E) o;
        Node<E> newNode = new Node<>(pred, e, null);
        // 第一次创建时, 那么第一个节点就是 first节点
        if (pred == null)
            first = newNode;
        else
            // 将 pred 的下一个节点指向新创建的节点
            pred.next = newNode;  
          
        // 将 pred 改为当前节点, 方便下一个元素操作
        pred = newNode;    
    }   

    // succ 是为空的, 表示直接在已有的数据后面追加元素的话, 所以将最后节点设置为新增元素的最后一个元素的节点
    if (succ == null) {
        last = pred;
    } else {
        // 原有数据后半部分拼接到现在链表的后半部分
        pred.next = succ;
        succ.prev = pred;
    } 

    // 当前的长度
    size += numNew;
    // 修改次数加1 
    modCount++;
    return true;
}

/**
 * 校验 index 的值满足:  0 <= index <= size
 */
private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

/*
 * 判断 index 是否大于等于 0 并且小于等于 size
 */
private boolean isPositionIndex(int index) {
    return index >= 0 && index <= size;
}

/**
 * 获取指定位置的节点
 */
Node<E> node(int index) {

    // 此次做了一个小优化: 当要查找的位置小于现有数据的一半, 从前往后找, 大于的话, 从后面开始找
    // size >> 1 相当于 size / 2
    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;
    }
}

从代码可知

  1. LinkedList 是基于双向链表实现了
  2. LinkedList 的数据是通过 first(节点) 和 last(节点) 和 size 三个共同维护的
  3. LinkedList 内部的数据通过泛型, 保持了自己的类型, 没有转为 Object。

5 LinkedList 几个常用的方法

5.1.1 添加数据

直接在链表末尾添加元素

// 直接添加一个元素
public boolean add(E e) {
    // 默认新增到链表的末尾
    linkLast(e);
    return true;
}

/**
 * 将入参的元素添加到链表的末尾
 */
void linkLast(E e) {

    // 获取链表的尾结点
    final Node<E> l = last;
    // 将数据封装为 Node 节点
    final Node<E> newNode = new Node<>(l, e, null);
    // 链表的尾结点等于新的节点
    last = newNode;

    // 如果链表一开始的尾结点为空, 表示链表一开始没有数据
    if (l == null)
        // 链表的头节点也等于当前的新节点
        first = newNode;
    else
        // 一开始的为节点有值, 将原来的尾结点的下一个节点设置为当前新的节点
        l.next = newNode;    
    
    // 链表个数 + 1
    size++;
    // 修改次数 + 1
    modCount++    
}

指定位置的插入

public void add(int index, E element) {

    // 判断 0 <= index <= size, 不满足抛出异常
    checkPositionIndex(index);

    // index == size 要插入的位置刚好在末尾
    if (index == size)
        linkLast(element);
    else 
        // 插入到某个节点的前面
        linkBefore(element, node(index));    
}

/**
 * 将元素插入到某个节点的前面
 */
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;    

    // 个数加 1
    size++;
    
    // 修改次数 + 1
    modCount++;        
}

在头部插入

public void addFirst(E e) {
    linkFirst(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++;        
}

还有前面看到的

  1. 插入一个 Collection 的 addAll(Collection c)
  2. 指定位置的插入一个 Collection 的 addAll(int index, Collection c)

5.1.2 删除数据

直接删除 (默认删除第一个元素)

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

/**
 * 删除链表第一个元素
 */
public E removeFirst() {

    final Node<E> f = first;
    // 头节点为空
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

/**
 * 删除指定的节点
 */
private E unlinkFirst(Node<E> f) {

    // 获取删除节点的数据
    final E element = f.item;

    // 找到删除元素的下一个元素
    final Node<E> next = f.next;

    // 清空删除元素的信息
    f.item = null;
    f.next = null;

    // 将头节点重新设置为删除元素的下一个元素
    first = next;

    // 如果原本删除元素就是没有后续元素时, 将最后的元素设置为 null
    if (next == null)
        last = null;
    else
    	// 将新的第一个元素的前置节点设置为 null
        next.prev = null;  
    // 元素个数 - 1    
    size--;
    // 修改次数 + 1
    modCount++;
    // 返回数据
    return element;          
}

指定位置的删除

public E remove(int index) {
	// 检测删除的位置是否正确
    checkElementIndex(index);
    return unlink(node(index));
}

private void checkElementIndex(int index) {
    // 如果不满足  0 <= index < size, 就抛出异常
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private boolean isElementIndex(int index) {
    return index >= 0 && index < size;
}

E unlink(Node<E> x) {

    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;
        // 设置删除节点前置节点为 null
        x.prev = null;
    }

    // 如果后置节点为空, 说明移除的为尾节点, 重新设置尾节点为删除节点的前置节点
    if (next == null) {
        last = prev;
    } else {
    	// 将后置节点的前置节点设置为前置节点
        next.prev = prev;
        // 设置删除节点后置节点为 null
        x.next = null;
    }
    
    // 将删除节点的数据设置为 null
    x.item = null;
    size--;
    modCount++;
    return element;
}

指定删除元素

public boolean remove(Object o) {

    // 需要删除的节点为 null
    if (o == null) {
        // 找到第一个为 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;
            }
        }
    }
}

除了上面几个还有

  1. 删除第一个 removeFirst()
  2. 删除最后一个 removeLast()
  3. 删除第一个符合的元素 removeFirstOccurrence(Object o)
  4. 删除最后一个符合的元素 removeLastOccurrence(Object o)

5.1.3 获取数据

获取指定位置的数据

public E get(int index) {
    // 确保 0 <= index < size
    checkElementIndex(index);
    // 定位到对应位置的节点的数据
    return node(index).item;
}

获取第一个的数据

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;
}

5.1.4 更新数据

更新指定位置节点的属性值

public E set(int index, E element) {

    // 确保 0 <= index < size
    checkElementIndex(index);
    // 获取指定位置的节点数据
    Node<E> x = node(index);
    // 获取指定节点是旧数据
    E oldVal = x.item;
    // 更新指定节点的数据
    x.item = element;
    // 返回旧数据
    return oldVal;
}

6 LinkedList 补充

1. LinkedList 实现了 Serializable 接口, 但是他的属性都是设置为 transient ?

LinkedList 重写了序列化方法 writeObject 和反序列化方法 readObject。 在序列化中, 重新通过遍历所有节点, 把所有节点数据写入到 ObjectOutputStream。

2. LinkedList 支持 fail-fast 机制 ?

通过继承关系可以指定 LinkedList 也是实现了 AbstractList, 具备了 modCount, 在修改中也会增加 modCount 的值, 所以 LinkedList 也支持 fail-fast 机制。

3. LinkedList不是一个线程安全的集合 ?

LinkedList 是线程不安全的, 如果需要保证线程的安全性, 可以考虑使用 Collections.synchronizedList(Lise l) 函数返回一个线程安全的 LinkedList 类。

4. 不要用 for 遍历 LinkedList ?

遍历的代码

List<String> list2 = new LinkedList<>();
list.add("1");
list.add("2");
list.add("3");

for (int i = 0; i < list2.size(); i++) {
	String item = list2.get(i);
	System.out.println(item);
}

源码中涉及的代码:

public class LinkedList {

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

    Node<E> node(int 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;
        }
    }
}

如上: 我们通过 for 遍历 LinkedList,

  1. 第一次 get(0), node(0), 就是 first 节点
  2. 第二次 get(1), node(1), 就是 first -> node1
  3. 第三次 get(2), node(2), 就是 first -> node1 -> node2

每次通过 get() 就是需要从第一个节点一直找到对应的位置, 才能找到需要的节点。
所以遍历 LinkedList 可以使用 foreach (foreach 循环的原理就是迭代器) 或者迭代器。

5. LinkedList 还有其他的作用吗

LinkedList 实现了 Deque 接口, 所以 LinkedList 可以作为双端队列, 同时 LinkedList 的双向链表的特点, 还可以作为 Stack 使用, 但是 LinkedList 的这 2 个功能,
如果没有什么特殊的要求的话, 都可以使用 ArrayDeque 替代, 后者的性能更好。

lcn29
关注
专栏目录
Java数据结构之单链表下
qq_42114509的博客
06-10 202
单链表的第二种添加可以按照编号顺序添加
Java LinkedList（Java自带链表类和Java实现链表）
weixin_44730746的博客
03-20 1328
Java LinkedList（Java自带链表类和Java实现链表）
java集合系列之LinkList
weixin_30362233的博客
03-28 159
概要 第1部分 LinkedList介绍第2部分 LinkedList数据结构第3部分 LinkedList源码解析(基于JDK1.6.0_45)第5部分 LinkedList示例 转载请注明出处：http://www.cnblogs.com/skywang12345/p/3308807.html 第1部分 LinkedList介绍 LinkedList简介 LinkedLis...
Java 集合系列05之 LinkedList详细介绍(源码解析)和使用示例
weixin_30642029的博客
02-20 85
概要 前面，我们已经学习了ArrayList，并了解了fail-fast机制。这一章我们接着学习List的实现类——LinkedList。和学习ArrayList一样，接下来呢，我们先对LinkedList有个整体认识，然后再学习它的源码；最后再通过实例来学会使用LinkedList。内容包括：第1部分 LinkedList介绍第2部分 LinkedList数据结构第3部分 LinkedLis...
java LinkedList
weixin_45129218的博客
03-25 326
LinkedList实现了双向链表和双端队列特点 可以添加任意元素(元素可以重复),包括null 线程不安全,没有实现同步 LinkedList底层维护了一个双向链表 LinkedList中维护了两个属性first和last分别指向首节点和尾节点 每个节点(Node对象),里面又维护了prev,next,item三个属性,其中通过prev指向前一个,通过next指向后一个节点,最终实现双向链表 所以LinkedList的元素的添加和删除,不是通过数组完成的,相对效率较高 public class Lin.
java学习之LinkedList（链表）
qq_45754762的博客
05-03 1669
java LinkedList是java中的链表结构，具有高效的增加和删除元素功能。
Java中集合LinkedList的原理与使用方法
08-25
LinkedList是Java集合框架中List接口的一个实现，它是一种基于链表结构的数据容器。本文将深入探讨LinkedList的原理和使用方法。 首先，LinkedList是一个双向链表，意味着每个元素（节点）都有指向前后元素的引用。...
Java集合 LinkedList 底层详解
奔跑的蜗牛
05-13 3078
Java集合的LinkedList底层详解 前一篇文章，已经讲过ArrayList的底层实现原理，今天学习LinkedList底层实现原理。 LinkedList类是List接口的实现类，它是一个集合，可以根据索引来随机的访问集合中的元素，还实现了Deque接口，它还是一个队列，可以当成双端队列来使用。虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，A...
java 集合之LinkedList 构造器 方法 遍历方法 listIterator
SKPrimin的博客
08-17 833
java 集合之LinkedList List 和 Deque 接口的双向链表实现。 实现所有可选的列表操作，并允许所有元素（包括空值）。 除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。 实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。 所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头
java集合 collection-list-LinkedList详解
08-31
总之，`LinkedList`是Java集合框架中一个重要的列表实现，适用于需要高效执行链式操作的场景。理解其工作原理和特性对于优化Java程序的性能至关重要。在实际编程中，开发者应根据具体需求选择合适的集合类型。
简单了解java集合框架LinkedList使用方法
08-18
"Java集合框架LinkedList使用方法" Java集合框架中的LinkedList是一个双向链表，具有链表底层实现的特点，查询速度慢，增删速度快。LinkedList是Java集合框架中的一个重要组件，广泛应用于各种软件系统中。本文将...
Java基础之LinkedList
qq_45344586的博客
04-09 1769
Java基础之LinkedList
java实现 LinkList
✈ 正在努力 の 寒江（StudiousTiger) ✌ 呐 ✈
04-22 306
介绍：通过单链表实现LinkList 对外接口： 源码： package algorithmBeauty.dataStructure.link.iLinkList; /** * @author : HuXuehao * @date : 2021年4月11日下午10:12:27 * @version : */ @SuppressWarnings("unused") public class MyLinkList<E> { private int size = 0; private
JAVA集合---LinkList
qq_35229940的博客
04-25 2237
LinkedList简介 LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList 实现 List 接口，能对它进行队列操作。 LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。 LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。 LinkedList 实现java.io.Serializable接口，这意味着LinkedList支
Java学习系列之LinkList
chengzi_wj_的博客
03-24 357
文章目录概述set和get函数 概述 以双向链表实现。链表无容量限制，但双向链表本身使用了更多空间，也需要额外的链表指针操作。 按下标访问元素—get(i)/set(i,e) 要悲剧的遍历链表将指针移动到位(如果i>数组大小的一半，会从末尾移起)。 插入、删除元素时修改前后节点的指针即可，但还是要遍历部分链表的指针才能移动到下标所指的位置，只有在链表两头的操作—add()，addFirst(...
Java LinkedList用法详解
li_w_ch的博客
09-05 1480
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。链表可分为单向链表和双向链表。 ArrayList和LinkedList的区别： ArrayList是List接口的一种实现，它是使用数组来实现的。 LinkedList也是List接口的一种实现，它是使用链表来实现的。 ArrayList遍历和查找元素比较快，而LinkedList添加和删除元素比较快。 ArrayList适用场景: 1）频繁访问列表.
java集合之LinkedList
Neo_Yuhao的博客
03-18 397
java集合之LinkedList
Java集合类之LinkedList
一个苟且偷生程序员的博客
06-05 320
LinkedList源码解析 LinkedList的初始化构造方法 无参构造 构造一个空集合 public LinkedList() { } 有参构造，传入一个Collection集合作为初始化参数 //记录LinkedList的大小 transient int size = 0; //LinkedList的头节点 transient Node<E> first; //LinkedList的尾节点 transient Node<E> last; /** *Linke
【Java】链表LinkedList
最新发布
qq_61635026的博客
07-06 1万+
链表（Linked List）是一种常见的数据结构，用于存储和组织数据。它由一系列节点（Node）组成，每个节点包含两个主要部分：数据域（Data）和指针域（Pointer）。 数据域存储节点所需的数据或信息，可以是任意类型的数据，如整数、字符、对象等。指针域则指向链表中的下一个节点，将节点连接起来形成链表结构。 链表中的节点并不一定按照物理上的连续位置存储，而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点，而无需像数组那样进行元素的移动。
深入解析Java LinkedList源码
"本文将深入探讨Java集合框架中的LinkedList源码，分析其内部结构和主要操作方法。LinkedList作为List接口的一个实现，基于双向链表设计，提供了高效插入和删除操作，但查找和修改性能相对较慢。" LinkedList在Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值