Java 集合体系 —— List 篇

zz0723202025-10-03 6:07

在Java集合框架中，List接口是最常用的数据结构之一，它代表一个有序的集合，允许元素重复且可以通过索引访问。本文将深入解析List接口的三个主要实现类------ArrayList、LinkedList和Vector，从底层结构、核心操作、源码实现到适用场景进行全面对比分析，帮助开发者在实际开发中做出更合适的选择。

一、List接口概述

List接口继承自Collection接口，定义了一组有序集合的操作规范，其核心特点包括：

  • 允许存储重复元素
  • 维护元素的插入顺序
  • 支持通过索引（int类型）访问元素
  • 提供了丰富的增删改查方法

List接口的主要方法包括：

  • add(E e)：在末尾添加元素
  • get(int index)：获取指定索引的元素
  • set(int index, E element)：替换指定索引的元素
  • remove(int index)：删除指定索引的元素
  • indexOf(Object o)：返回元素首次出现的索引

ArrayList、LinkedList和Vector作为List接口的具体实现，在数据结构、性能特性和线程安全性上各有不同，下面分别进行详细分析。

二、ArrayList详解与源码分析

1. 底层数据结构

ArrayList是基于动态数组 实现的List，其底层维护了一个Object类型的数组（transient Object[] elementData），默认初始容量为10。当元素数量超过当前容量时，会自动进行扩容操作。

2. 核心源码分析

构造方法
java 复制代码 
// 默认构造方法，初始化为空数组，首次添加元素时会扩容到10
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// 指定初始容量的构造方法
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);
    }
}
添加元素
java 复制代码 
public boolean add(E e) {
    // 确保容量足够，不足则扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

// 扩容核心逻辑
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 新容量为旧容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 复制元素到新数组
    elementData = Arrays.copyOf(elementData, newCapacity);
}
获取元素
java 复制代码 
public E get(int index) {
    // 检查索引是否越界
    rangeCheck(index);
    return elementData(index);
}

// 直接通过数组索引访问，时间复杂度O(1)
E elementData(int index) {
    return (E) elementData[index];
}
删除元素
java 复制代码 
public E remove(int index) {
    rangeCheck(index);
    modCount++;
    E oldValue = elementData(index);
    
    // 计算需要移动的元素数量
    int numMoved = size - index - 1;
    if (numMoved > 0)
        // 移动元素填补空位
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    elementData[--size] = null; // 帮助GC回收
    
    return oldValue;
}

3. 性能特点

  • 随机访问：通过索引直接访问元素，时间复杂度为O(1)，性能优异
  • 添加元素：尾部添加（add(E e)）时间复杂度为O(1)，但扩容时需要复制数组，最坏情况为O(n)
  • 插入/删除元素：需要移动大量元素，时间复杂度为O(n)
  • 内存占用：连续内存空间，存在一定的空间浪费（为了避免频繁扩容）

三、LinkedList详解与源码分析

1. 底层数据结构

LinkedList基于双向链表实现，每个节点（Node）包含三个部分：

  • 存储的元素（item）
  • 前驱节点引用（prev）
  • 后继节点引用（next）

其内部维护了两个指针：

  • transient Node<E> first：指向头节点
  • transient Node<E> last：指向尾节点

2. 核心源码分析

节点结构
java 复制代码 
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;
    }
}
添加元素
java 复制代码 
// 尾部添加元素
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++;
}

// 指定位置插入元素
public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}
获取元素
java 复制代码 
public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

// 查找指定索引的节点，时间复杂度O(n)
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;
    }
}
删除元素
java 复制代码 
public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

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; // 帮助GC
    size--;
    modCount++;
    return element;
}

3. 性能特点

  • 随机访问：需要遍历链表，时间复杂度为O(n)，性能较差
  • 添加/删除元素：只需修改节点引用，时间复杂度为O(1)（已知节点位置时）
  • 内存占用：每个元素需要额外存储前后节点引用，内存开销较大
  • 迭代性能：迭代器遍历性能好，但随机访问性能差

四、Vector详解与源码分析

1. 底层数据结构

Vector与ArrayList类似，也是基于动态数组 实现，但它是线程安全 的集合。其底层同样维护了一个Object数组（protected Object[] elementData），默认初始容量为10。

Vectory与ArrayListd的区别：

1.Vector是线程同步的，所以Vector线程安全，但ArrayList线程不安全。

2.Vector的性能要逊于ArrayList。

3.ArrayList在调用空参构造时，此时，会初始化一个长度为0的Object数组，只有当向ArrayList中添加元素时，才会扩容至长度为10的Object数组。而Vector在调用空参构造时，会直接初始化一个长度为10的Object数组，不会在添加元素时再扩容。

4.ArrayList中的元素是允许为null的，但Vector中不允许出现null元素。

2. 核心源码分析

线程安全实现

Vector的线程安全主要通过在方法上添加synchronized关键字实现：

java 复制代码 
// 添加元素，方法上有synchronized关键字
public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

// 获取元素
public synchronized E get(int index) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);

    return elementData(index);
}
扩容机制

与ArrayList不同，Vector默认扩容为原来的2倍：

java 复制代码 
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // capacityIncrement为扩容增量，默认为0，此时扩容为原来的2倍
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

3. 性能特点

  • 功能：与ArrayList基本一致，都提供动态数组的功能
  • 线程安全：所有方法都被synchronized修饰，保证线程安全
  • 性能：由于同步开销，在单线程环境下性能不如ArrayList
  • 扩容：默认扩容为原来的2倍，比ArrayList的1.5倍更激进

五、三种集合的对比与适用场景

特性 ArrayList LinkedList Vector
底层结构 动态数组 双向链表 动态数组
线程安全 否 否 是
随机访问 快（O(1)） 慢（O(n)） 快（O(1)）
插入删除 慢（O(n)） 快（O(1)） 慢（O(n)）
内存占用 较少（连续空间） 较多（节点引用） 较少（连续空间）
扩容机制 1.5倍 无需扩容 2倍

适用场景选择建议：

  1. ArrayList：

    • 适用于频繁随机访问元素的场景
    • 适合元素数量变化不大，或主要在尾部添加/删除元素的操作
    • 单线程环境下的首选List实现

  2. LinkedList：

    • 适用于频繁在中间位置插入/删除元素的场景
    • 适合实现队列、栈等数据结构（LinkedList实现了Deque接口）
    • 元素数量不确定且经常变化的场景

  3. Vector：

    • 适用于多线程环境下需要线程安全的场景
    • 但在实际开发中，更推荐使用Collections.synchronizedList(new ArrayList<>())替代
    • 对性能要求不高，且需要兼容旧代码的场景

六、总结

ArrayList、LinkedList和Vector作为List接口的三大实现类，各有其独特的设计和性能特性：

  • ArrayList以动态数组为基础，提供了高效的随机访问能力，适合读取操作频繁的场景
  • LinkedList基于双向链表实现，在插入和删除操作上表现优异，适合频繁修改的场景
  • Vector作为线程安全的动态数组，虽然保证了线程安全，但性能开销较大，在现代开发中已较少直接使用

在实际开发中，应根据具体的业务场景、操作类型和并发需求选择合适的List实现，以达到最优的性能表现。同时，需要注意的是，这三个集合类都不是线程安全的（除Vector外），在多线程环境下使用时需要额外的同步措施。

相关推荐
-雷阵雨-2 小时前
数据结构——LinkedList和链表
java·开发语言·数据结构·链表·intellij-idea
fly-phantomWing6 小时前
Maven的安装与配置的详细步骤
java·后端·maven·intellij-idea
2401_841495649 小时前
【数据结构】红黑树的基本操作
java·数据结构·c++·python·算法·红黑树·二叉搜索树
学编程的小鬼9 小时前
SpringBoot 自动装配原理剖析
java·spring boot·后端
@@神农10 小时前
maven的概述以及在mac安装配置
java·macos·maven
杜子不疼.10 小时前
【C++】玩转模板：进阶之路
java·开发语言·c++
夜晚中的人海10 小时前
【C++】异常介绍
android·java·c++
Le1Yu11 小时前
2025-9-28学习笔记
java·笔记·学习
C++chaofan11 小时前
项目中为AI添加对话记忆
java·数据结构·人工智能·redis·缓存·个人开发·caffeine
热门推荐
01GitHub 镜像站点02KGG转MP3工具|非KGM文件|解密音频03OpenSpeedy简介04UV安装并设置国内源05jdk21下载、安装（Windows、Linux、macOS）06在国行 macOS 下用 DeepSeek 补齐 Xcode 26 的 AI 能力：问题、原因与 mitmproxy 解决方案（含可用脚本与安装教程）07Linux下V2Ray安装配置指南08两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答09阿里最新开源Wan2.2-Animate-14B 本地部署教程：统一双模态框架，MoE架构赋能电影级角色动画与替换10最新b站加密关键字段的逆向（视频和评论爬取）