java集合之LinkedList

最新推荐文章于 2025-12-28 23:02:17 发布
原创 最新推荐文章于 2025-12-28 23:02:17 发布 · 317 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

本文详细介绍了LinkedList的数据结构、容量特性、链表存储方式以及与ArrayList的不同，包括头插法、尾插法等典型操作，并讨论了其添加元素和扩容机制。

LinkedList实现了List和Deque，说明它既有List的特性，也有Deque的特性，它既然是一个容器，那么自然就是用来存放数据的，它与ArrayList又有什么区别呢，容量是多少，底层用什么结构来存放数据，有没有扩容等等，下面我们带着问题来看看。
在这里插入图片描述

1、采用什么结构存放数据

从下面的结构中可以看出，LinkedList底层采用的是链表来

   /**
   * Node是LinkedList的一个内部类，每一个元素都是封装为Node的结构往链表里面存放的
   * item代表的存放的数据本身
   * next指向后一个节点
   * prev指向前一个节点
   * /
   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;
      }
    }

    /**
     * 链表头
     */
    transient Node<E> first;

    /**
     * 链表尾
     */
    transient Node<E> last;
2、重要属性
	/**
     *已经存放的元素个数
     */
    transient int size = 0;

    /**
     * 链表头
     */
    transient Node<E> first;

    /**
     * 链表尾
     */
    transient Node<E> last;
3、构造器
	/**
     * 无参构造函数
     */
   	public LinkedList() {
    }

    /**
     * 构造一个包含指定的元素的列表集合
     */
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }
    /**
    * 前面的带参构造函数是调用了下面的addAll方法
    */
    public boolean addAll(Collection<? extends E> c) {
    	// 构造函数调用时，此时size=0
        return addAll(size, c);
    }
    public boolean addAll(int index, Collection<? extends E> c) {
    	// 健壮性保障
        checkPositionIndex(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

        Node<E> pred, succ;
        // index是添加元素的位置，如果index==size,则从尾部添加，构造函数调用进来的时候，index==size==0
        // index!=size时，说明元素需要添加在具体的位置，那么先找到index位置的节点succ = node(index); 然后进行插入
        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);
            if (pred == null)
            	// 首个节点赋值给first
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }
		// 如果是从尾部添加，last需要重新赋值，否则不用变更last
        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;
        modCount++;
        return true;
    }
4、添加元素以及怎么扩容

LinkedList不需要扩容，它不像ArrayList底层采用数组存放，Linked采用的是链表结构，所以它能不能继续放数据，看内存够不够。

5、有代表性的特有方法
-- 头插法
public void addFirst(E e) {
	linkFirst(e);
}
public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}
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
        last = newNode;
    else
    // 否则将老的头节点的前驱节点指向当前的新节点
        f.prev = newNode;
    size++;
    modCount++;
}

-- 尾插法
public void addLast(E e) {
   linkLast(e);
}
public boolean add(E e) {
    linkLast(e);
    return true;
}
public boolean offer(E e) {
    return add(e);
}
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++;
}

-- 判断集合是否包含某个元素
public boolean contains(Object o) {
   return indexOf(o) != -1;
}
-- 返回此列表中指定元素第一次出现的索引，如果此列表不包含该元素，则返回-1，此处代码简单，无需多言
public int indexOf(Object o) {
    int index = 0;
    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;
}

-- 返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1，从链表后往前找，此处代码简单，无需多言
public int lastIndexOf(Object o) {
    int index = size;
    if (o == null) {
        for (Node<E> x = last; x != null; x = x.prev) {
            index--;
            if (x.item == null)
                return index;
        }
    } else {
        for (Node<E> x = last; x != null; x = x.prev) {
            index--;
            if (o.equals(x.item))
                return index;
        }
    }
    return -1;
}

-- 返回链表头，但不删除头节点
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;
}
-- 检索但不删除此列表的最后一个元素，如果此列表为空，则返回null。
 public E peekLast() {
   final Node<E> l = last;
   return (l == null) ? null : l.item;
}

-- 检索并删除此列表的头
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);
}
private E unlinkFirst(Node<E> f) {
   // assert f == first && f != null;
   // 记下f节点(头节点)
   final E element = f.item;
   // 记下头节点的后驱节点
   final Node<E> next = f.next;
   // 清空头节点的元素，以及指向
   f.item = null;
   f.next = null; // help GC
   first = next;
   if (next == null)
   // 如果头节点的下一个元素为空，则说明链表已经没有元素了，
   // last也应该指向null，如果不处理last，可能会导致last一直指向某个对象，无法被回收
       last = null;
   else
   // 清空新的头节点的前驱节点
       next.prev = null;
   size--;
   modCount++;
   return element;
}
-- 检索并删除此列表的尾 正好与前面的相反
 public E pollLast() {
    final Node<E> l = last;
    return (l == null) ? null : unlinkLast(l);
}
private E unlinkLast(Node<E> l) {
    // assert l == last && l != null;
    final E element = l.item;
    // 记下当前元素的前驱节点
    final Node<E> prev = l.prev;
    // 清空当前节点的元素和指向
    l.item = null;
    l.prev = null; // help GC
    // 将尾节点指向当前节点的前驱节点
    last = prev;
    if (prev == null)
    // 如果当前节点的前驱节点为null，说明已经是最后一个元素，需要处理first，以防first一直指向某个节点，无法回收
        first = null;
    else
    // 否则清空当前节点的前驱节点的后驱节点
        prev.next = null;
    size--;
    modCount++;
    return element;
}

-- 将链表当成栈，弹出其中的元素 最终调用的还是unlinkFirst
public E pop() {
    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) {
    // assert f == first && f != null;
    final E element = f.item;
    final Node<E> next = f.next;
    f.item = null;
    f.next = null; // help GC
    first = next;
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}

-- 将链表当成栈，并往里面push元素，最终调用的也是LinkedList本身的方法linkFirst
public void push(E e) {
    addFirst(e);
}
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++;
}

-- 删除元素
public E remove() {
    return removeFirst();
}
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
        // 比较熟悉的unlinkFirst
    return unlinkFirst(f);
}

-- 删除指定元素
-- remove找到要删除的节点  unlink执行具体的删除操作，就是将当前节点该清空的清空，
-- 将当前节点的前驱和后驱节点的指向设置好，然后设置好头尾节点的指向
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;
}

-- 删除指定位置的元素
-- 比上一个删除多了一步，就是找到指定位置的元素node(index)
public E remove(int index) {
   checkElementIndex(index);
    return unlink(node(index));
}
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;
    }
}

-- 删除尾部节点 又是熟悉的unlinkLast
public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}
private E unlinkLast(Node<E> l) {
   // assert l == last && l != null;
    final E element = l.item;
    final Node<E> prev = l.prev;
    l.item = null;
    l.prev = null; // help GC
    last = prev;
    if (prev == null)
        first = null;
    else
        prev.next = null;
    size--;
    modCount++;
    return element;
}

-- 替换指定位置的节点的内容
public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}
Java 集合之LinkedList源码分析
01-20
Java API中提供了链表的Java实现—LinkedList下。LinkedList是通过节点的连接实现链表的数据结构，向linkedList中插入或删除元素的速度是特别快，而随机访问的速度相对较慢，这个是由于链表本身的性质造成的，在链表...
Java集合框架LinkedList详解及实例
08-30
《Java集合框架LinkedList详解及实例》 在Java编程语言中，集合框架是处理对象集合的重要工具，而LinkedList是这个框架中的一个重要组成部分。LinkedList是一种双端链表，它不仅提供了列表的基本功能，还支持高效的...
Java集合之LinkedList
骑着猪猪去旅行的博客
10-30 2627
LinkedList是实现了List和Deque接口的双向链表，实现了所有可选列表的操作，允许存放所有元素（包括null）
JAVA 集合之 LinkedList
an_vana的博客
08-08 1596
LinkedList 前言 本文作为我学习 Java 集合 LinkedList 的一个记录与总结，如有疏漏或不足之处欢迎指出共同进步！ 一、LinkedList 简介 1.1 LinkedList 概述 LinkedList 是可以动态增长或缩减的索引序列，其底层是基于双向链表实现的 LinkedList 类内部维护了一个双向链表，因此可以完成高效的的插入和删除，但由于顺序存取的原因其查询效率不如 ArrayList ，后者可以通过 index 直接取得相应的值。 LinkedList 与 A
JAVA集合之LinkedList
ABC1234567890ABM的博客
05-13 408
LinkedList底层是一个双向链表，他维护了两个属性fist和last分别指向首节点和尾节点，每个节点（Node对象）中又维护的prev、next、item三个属性，通过prev指向前一个节点，next指向后一个节点，item就是具体的值 当使用无参构造器去构造LinkedList集合时，其实只是做了一个初始化，并没有其他作用。而当使用有参构造器去构造LinkedList，它只有一个参数，参数类型是集合类。有参构造方法调用了无参构造方法，并调用了addAll方法。addAll方法的主要作用是：将指定集.
Java集合之LinkedList详解
qq_39939541的博客
06-25 2936
例如containsAll、removeAll、retainAll等方法，这些方法可以被ArrayList直接继承和使用，从而避免了重复实现这些操作。同时，AbstractCollection也提供了一些抽象方法，例如size、iterator、toArray等方法，这些方法需要由具体的集合类去实现，LinkedList也需要实现这些方法以完成自身的功能。AbstractList是List接口的一个抽象实现，实现了List接口的大部分方法，包括添加、删除、获取元素、遍历等。
java linkedlist 长度_Java集合之LinkedList
weixin_32017139的博客
02-13 2295
对于LinkedList来说，其基本特性如下：基本特性结论元素是否允许为null是元素是否允许重复是是否有序是是否线程安全否与ArrayList是一致的。源码分析本文使用的是JDK 1.8.0_201的源码。成员变量LinkedList是基于链表实现的，并且是双向链表结构。LinkedList类的主要成员变量：成员变量作用transient int size = 0;集合中元素的个数transie...
Java集合之LinkedList总结
再见时光的博客
03-26 689
LinkedList 是一个常用的容器，它与 ArrayList 都提供了复制一个 Collection 类型的列表的构造器，如果你有某个业务场景需要频繁新增，实时的更新内存中的数据，又要提供查询，可以使用 LinkedList 新增，外部调用查询的使用 ArrayList queryList = new ArrayList(linkedList) 的方式返回数据，则可以提供系统性能。如果不了解 ArrayList 和 LinkedList 的内部结构和实现细节，我们又怎么能够知道在什么场景下使用什么容器呢
Java集合Collection之LinkedList
weixin_52890053的博客
03-20 972
最近在复习集合的相关知识点，以前只知道ArrayList的基本用法与功能，发现系统学习后，List的还有另一个实现类LinkedList，学习后发现LinkedList别有洞天。对于不爱学习的我，赶紧记录下，怕以后忘记了这个一个好东西！！！
【Java 集合】LinkedList
LCN29的博客
11-26 1441
** 当前节点的内容 */E item;/** 下一个节点 *//** 上一个节点 */// 当前节点的数据 = element// 当前节点的后置节点 = next// 当前节点的前置节点 = prevNode 节点中除了指向下一个节点的 next, 还包含指向上一个节点的 prev, 所以 LinkedList 是一个双向的链表。
java集合之LinkedList详解
热门推荐
zhao_xinhu的博客
09-15 2万+
我们上一次说到List的ArrayList，我们这次去看下LinkedList---顾名思义是链表，链表的优点就不用说了吧，增删效率比较高（具体的朋友们上网看吧），先来看下LinkedList的整体构架：  首先我们看到了LinkedList间接的实现了List接口（说明LinkedList是有list的特性的，add，remove等）、实现了Cloneable（可复制）、Serializa...
简单了解java集合框架LinkedList使用方法
08-18
"Java集合框架LinkedList使用方法" Java集合框架中的LinkedList是一个双向链表，具有链表底层实现的特点，查询速度慢，增删速度快。LinkedList是Java集合框架中的一个重要组件，广泛应用于各种软件系统中。本文将...
Java集合系列之LinkedList源码分析
08-27
Java集合系列之LinkedList源码分析 概述： 本文详细介绍了Java集合系列之LinkedList的源码分析，主要介绍了LinkedList的底层实现、成员变量、构造器、增删改查方法等。LinkedList是一种基于双向链表的数据结构，...
【java入门到放弃】网络
WZDBXHNL的博客
12-28 1098
防火墙既可以是硬件，也可以是软件，本质上是一种，而不是只能对应某一种形态。
点赞系统问题
amdkk的博客
12-26 1120
​​：Spring Pulsar 提供的接口，允许通过customize方法深度定制消费者行为。批量接收策略配置。：控制批量消息接收策略maxNumMessages：单次批量拉取多少条信息timeout：超时后触发批量处理。NACK重试策略当消费者调用时触发重试。：消息重投递的退避策略接口。.minDelayMs(1000) // 初始延迟 1 秒 .maxDelayMs(60000) // 最大延迟 60 秒 .multiplier(2) // 指数退避倍数。
抽象类和接口的区别
tryxr的博客
12-27 1108
本文对比了Java中接口（Interface）与抽象类（AbstractClass）的8个核心区别。主要差异包括：抽象类使用abstract class定义，支持单继承，可包含实例字段和构造器，体现"is-a"关系；接口使用interface定义，允许多实现，仅包含常量，体现"can-do"能力。抽象类适合共享代码和状态，接口适合定义跨类能力。建议优先使用接口定义能力，仅在需要共享状态或实现模板方法时使用抽象类，并考虑组合优于继承。二者可结合使用，如Shape抽象类实
blob是啥
最新发布
wniuniu_的博客
12-28 853
Onode: 代表一个 Ceph 对象（如Extent: 逻辑段，表示对象内某个偏移量（Offset）到长度（Length）的区间。Blob物理存储单元的抽象。它代表磁盘上的一组块，是 BlueStore 执行**压缩（Compression）和校验（Checksum）**的最小独立边界。简单类比：如果 Onode 是“一本书”，Extent 是“书页的页码”，那么Blob 就是“装订在一起的一叠纸”。这叠纸不仅存了文字（数据），边缘还盖了防伪印章（Checksum）。你说得对，
spring boot 运行测试类时：Error creating bean with name ‘serverEndpointExporter‘ 问题
csdndd521的博客
12-26 409
这个在Websocket中，注入不进去，单元测试时报错。直接在@SpringBootTest加入。
Java集合类LinkedList
03-11
### Java 中 LinkedList 集合类 #### 什么是 LinkedList 集合 `LinkedList` 是一种双向链表的数据结构，在 Java 编程中属于 `List` 接口的一种实现形式[^1]。这种数据结构允许元素之间通过指针相互链接，从而形成一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值