从 ArrayList 到 LinkedList：Java 集合中数组与链表的深度对比

love_muming2026-06-03 9:48

前言

在 Java 集合框架中，ArrayList 和 LinkedList 是最常用的两种 List 实现。ArrayList 基于动态数组，提供了高效的随机访问，但在中间位置插入或删除元素时，需要移动后续所有元素，性能开销较大。正是为了弥补这一缺陷，LinkedList（基于双向链表）应运而生，它在任意位置插入和删除操作上具有常数时间复杂度。本文将首先剖析 ArrayList 的底层结构与性能瓶颈，然后深入讲解链表的原理与实现，最后系统对比两者的核心差异，帮助你在不同场景下做出最合适的选择。

1. ArrayList的缺陷

java 复制代码 
public class ArrayList<E> extends AbstractList<E>
  implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
  // ...
  // 默认容量是10
  private static final int DEFAULT_CAPACITY = 10;
  //...
  // 数组：用来存储元素
  transient Object[] elementData; // non-private to simplify nested class access
  // 有效元素个数
  private int size;
  public ArrayList(int initialCapacity) {
  if (initialCapacity > 0) {
    this.elementData = new Object[initialCapacity];
  } else if (initialCapacity == 0) {
    this.elementData = EMPTY_ELEMENTDATA;
    } else {
         throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
    }
  }

由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此：java集合中又引入了LinkedList，即链表结构。

2. 链表

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

1. 单向或者双向

2. 带头或者不带头

3. 循环或者非循环

链表的实现

java 复制代码 
// 1、无头单向非循环链表实现
public class MySingleLinkedList {
    //每一个链节都是一个整体创造一个内部类
    static class ListNode{
        private int val;
        private ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }
    //head标记头节点
    public ListNode head;

    //头插法
    public void addFirst(int data){
        ListNode Nodes = new ListNode(data);
        Nodes.next = head;
        head = Nodes;
    }
    //尾插法
    public void addLast(int data){
        ListNode Nodes = new ListNode(data);
        ListNode node = head;
        while (node.next != null){
            node = node.next;
        }
        node.next = Nodes;
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
        ListNode slow = head;
        ListNode fast = slow.next;
        ListNode Nodes = new ListNode(data);
        if (index == 0){
            addFirst(data);
            return;
        }
        for (int i = 1;i<index;i++){
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = Nodes;
        Nodes.next = fast;
    }
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        ListNode node = head;
        while (node != null){
            if(node.val == key){
                return true;
            }
            node = node.next;
        }
         return false;
    }
    //删除第一次出现关键字为key的节点
    public void remove(int key){
        ListNode node = head;
        if(node.val == key){
            head = head.next;
            return;
        }
        while(node.next != null){
            if(node.next.val == key){
                node.next = node.next.next;
                return;
            }
            node = node.next;
        }
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
        ListNode node = head;
        while(node.next != null){
            if(node.val == key){
                head = head.next;
                node = head;
                continue;
            }
            if(node.next.val == key){
                node.next = node.next.next;
                continue;
            }
            node = node.next;
        }
    }
    //得到单链表的长度
    public int size(){
        int num = 0;
        ListNode node = head;
        while (node != null){
            node = node.next;
            num++;
        }
        return num;
    }
    //打印链表
    public void display(){
        ListNode node = head;
        while (node != null){
            System.out.print(node.val+" ");
            node = node.next;
        }
        System.out.println();
    }
}

3.LinkedList的模拟实现

我们实现了无头单向非循环链表实现，则无头双向链表实现则是在此基础上每一个节点加入对是一个节点的标记

java 复制代码 
// 2、无头双向链表实现
public class MyLinkedList {
    static class LinkNode{
        private int val;
        private LinkNode prev;//上一个节点
        private LinkNode next;//下一个节点

        public LinkNode(int val) {
            this.val = val;
        }
    }
    public LinkNode first;//头节点
    public LinkNode last;//尾节点
    //头插法
    public void addFirst(int data){
        LinkNode node = new LinkNode(data);
        if(first == null){
            first = node;
            last = node;
            return;
        }
        node.next = first;
        first.prev = node;
        first = node;
    }
    //尾插法
    public void addLast(int data){
        LinkNode node = new LinkNode(data);
        if(first == null){
            first = node;
            last = node;
            return;
        }
        last.next = node;
        node.prev = last;
        last = node;
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
        LinkNode cur = first;
        LinkNode node = new LinkNode(data);
        if (index == 0){
            addFirst(data);
            return;
        }
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        node.prev = cur.prev;
        node.next = cur;
        cur.prev.next = node;
        cur.prev = node;
    }
    //查找是否包含关键字key是否在双向链表当中
    public boolean contains(int key){
        LinkNode node = first;
        while(node != null){
            if(node.val == key){
                return true;
            }
            node = node.next;
        }
        return false;
    }
    //删除第一次出现关键字为key的节点
    public void remove(int key){
        LinkNode node = first;
        if (node.val == key){
            first = node.next;
            return;
        }
        while(node != null){
            if (node.val == key){
                node.prev.next = node.next;
                if (node.next != null)
                    node.next.prev = node.prev;
                else last = node.prev;
                return;
            }
            node = node.next;
        }
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
        LinkNode node = first;
        while(node != null){
            if (node.val == key){
                if (node.prev != null){
                    node.prev.next = node.next;
                } else {
                    first = node.next;
                    node = first;
                    continue;
                }
                if (node.next != null){
                    node.next.prev = node.prev;
                } else {
                    last = node.prev;
                    return;
                }
                node = node.next;
                continue;
            }
            node = node.next;
        }
    }
    //得到双向链表的长度
    public int size(){
        int num = 0;
        LinkNode node = first;
        while (node != null){
            node = node.next;
            num++;
        }
        return num;
    }
    //打印双向链表
    public void display(){
        LinkNode node = first;
        while (node != null){
            System.out.print(node.val+" ");
            node = node.next;
        }
        System.out.println();
    }
}

4.LinkedList的使用

【说明】

  1. LinkedList实现了List接口
  2. LinkedList的底层使用了双向链表
  3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问
    比特就业课4. LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)
  4. LinkedList比较适合任意位置插入的场景

1. LinkedList的构造

方法 解释
LinkedList() 无参构造
public LinkedList(Collection<? extends E> c) 使用其他集合容器中元素构造List
java 复制代码 
public static void main(String[] args) {
  // 构造一个空的LinkedList
  List<Integer> list1 = new LinkedList<>();
  List<String> list2 = new java.util.ArrayList<>();
  list2.add("JavaSE");
  list2.add("JavaWeb");
  list2.add("JavaEE");
  // 使用ArrayList构造LinkedList
  List<String> list3 = new LinkedList<>(list2);
}

2. LinkedList的其他常用方法介绍

方法 解释
boolean add(E e) 尾插 e
void add(int index, E element) 将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c) 尾插 c 中的元素
E remove(int index) 删除 index 位置元素
boolean remove(Object o) 删除遇到的第一个 o
E get(int index) 获取下标 index 位置元素
E set(int index, E element) 将下标 index 位置元素设置为 element
void clear() 清空
boolean contains(Object o) 判断 o 是否在线性表中
int indexOf(Object o) 返回第一个 o 所在下标
int lastIndexOf(Object o) 返回最后一个 o 的下标
List subList(int fromIndex, int toIndex) 截取部分 list
java 复制代码 
public static void main(String[] args) {
  LinkedList<Integer> list = new LinkedList<>();
  list.add(1); // add(elem): 表示尾插
  list.add(2);
  list.add(3);
  list.add(4);
  list.add(5);
  list.add(6);
  list.add(7);
  System.out.println(list.size());
  System.out.println(list);
  // 在起始位置插入0
  list.add(0, 0); // add(index, elem): 在index位置插入元素elem
  System.out.println(list);
  list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
  list.removeFirst(); // removeFirst(): 删除第一个元素
  list.removeLast(); // removeLast(): 删除最后元素
  list.remove(1); // remove(index): 删除index位置的元素
  System.out.println(list);
  // contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
  if(!list.contains(1)){
    list.add(0, 1);
  }
  list.add(1);
  System.out.println(list);
  System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
  System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
  int elem = list.get(0); // get(index): 获取指定位置元素
  list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
  System.out.println(list);
// subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
  List<Integer> copy = list.subList(0, 3);
  System.out.println(list);
  System.out.println(copy);
  list.clear(); // 将list中元素清空
  System.out.println(list.size());
}

3. LinkedList的遍历

java 复制代码 
public static void main(String[] args) {
  LinkedList<Integer> list = new LinkedList<>();
  list.add(1); // add(elem): 表示尾插
  list.add(2);
  list.add(3);
  list.add(4);
  list.add(5);
  list.add(6);
  list.add(7);
  System.out.println(list.size());
  
  // foreach遍历
  for (int e:list) {
    System.out.print(e + " ");
  } 
  System.out.println();
  
  // 使用迭代器遍历---正向遍历
  ListIterator<Integer> it = list.listIterator();
  while(it.hasNext()){
    System.out.print(it.next()+ " ");
  }
  System.out.println();
  
  // 使用反向迭代器---反向遍历
  ListIterator<Integer> rit = list.listIterator(list.size());
  while (rit.hasPrevious()){
    System.out.print(rit.previous() +" ");
  }  
  System.out.println();
}

5. ArrayList和LinkedList的区别

不同点 ArrayList LinkedList
存储空间上 物理上一定连续 逻辑上连续，但物理上不一定连续不同点
随机访问 支持O(1) 不支持：O(N)
头插 需要搬移元素，效率低O(N) 只需修改引用的指向，时间复杂度为O(1)
插入 空间不够时需要扩容 没有容量的概念
应用场景 元素高效存储+频繁访问 任意位置插入和删除频繁

总结

ArrayList 与 LinkedList 是 Java 集合框架中 List 接口的两种经典实现，它们各有优劣，适用于不同的场景。

核心区别总结：

  1. 底层数据结构 ：ArrayList 基于动态数组，内存连续；LinkedList 基于双向链表，内存不连续。
  2. 时间复杂度 ：
    • 随机访问 (get/set) ：ArrayList 为 O(1)，LinkedList 为 O(n)。
    • 任意位置插入/删除 ：ArrayList 平均为 O(n)（需移动元素），LinkedList 为 O(1)（仅需修改指针）。
    • 头部插入/删除 ：ArrayList 为 O(n)，LinkedList 为 O(1)。
  3. 内存与额外开销 ：ArrayList 预分配连续内存，可能有空间浪费；LinkedList 每个元素需存储前后节点引用，内存开销更大。
  4. 迭代器性能 ：ArrayList 的迭代器性能极佳；LinkedList 的迭代器在遍历时也需要按节点跳转。

选择建议：

  • 优先选择 ArrayList ：当你的主要操作是按索引随机访问、遍历 ，而插入和删除操作较少，或者主要在尾部进行时。这是绝大多数情况下的默认选择，因为其缓存友好，整体性能更优。
  • 考虑选择 LinkedList ：当你的应用场景需要频繁在列表中间或头部进行插入和删除操作，并且随机访问的需求很少时。例如实现队列、双端队列，或需要大量元素重排的算法。

在实际开发中，应结合具体的数据规模、操作频率和性能测试来做出最终决策。理解两者的底层原理，是写出高效、健壮 Java 代码的基础。

相关推荐
jsl_jsl_jsl41 分钟前
☕ Java 高并发进阶（三）：Java 锁体系全景解析——从 Synchronized 到 AQS 高阶锁
java
荣码44 分钟前
Java后端用LangChain搭大模型应用，我踩了5个坑
java
JAVA9651 小时前
JAVA面试-并发篇 04-synchronized和ReentrantLock 的区别是什么
java·面试
我是一只码蚁1 小时前
《别再死记面向对象了，我家咖啡机就是最好的老师》
java·后端
ZenosDoron1 小时前
malloc规范
java·开发语言
codeejun1 小时前
每日一Go-71、理论知识：CAP 、一致性原理 、Raft 机制（简化实现一个 Raft）
java·开发语言·golang
阿杰 AJie1 小时前
ExcelUtils样式相关工具
java·后端
Aotman_1 小时前
JavaScript数组对象中指定字段转换
java·开发语言·前端·javascript·vue.js·前端框架·es6
skywalker_111 小时前
Maven速通
java·maven
热门推荐
012026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf02GitHub 镜像站点03【AI】2026 年具身智能模型和世界模型总结04Codex 下载安装指南：Windows 和 macOS 官方版下载05【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法06裂开！ChatGPT 居然开始要手机号验证，附详细解决方法07CC-Switch 下载、安装与使用配置指南【2026.5.29】08CC-Switch & Claude 基于 Linux 服务器安装使用指南09Codex 接入 DeepSeek API 完整配置文档10几个好用的ip纯净度检测网站