JDK 8 ArrayList 详解及详细源码展示

原创 已于 2025-06-24 22:42:25 修改 · 268 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#JDK8 #源码 #学习

于 2025-06-22 08:03:33 首次发布

JDK 8 ArrayList 详解

Java 8 中的 ArrayList 是最常用的集合类之一，它基于动态数组实现，支持自动扩容。下面我将详细解析 ArrayList 的核心概念、实现原理和源码。

一、核心概念

1. 数据结构
  • 动态数组：内部使用Object[]存储元素，支持随机访问。
2. 关键参数
  • 初始容量：10（默认），创建时分配的数组大小。
  • 负载因子：隐式为1，当元素数量超过数组容量时触发扩容。
  • 扩容机制：每次扩容为原容量的1.5倍（oldCapacity + (oldCapacity >> 1)）。
3. 特点
  • 优点：随机访问快（O(1)），支持动态扩容。
  • 缺点：插入/删除效率低（O(n)），需移动元素。

二、源码解析

1. 类定义与成员变量
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 序列化版本号
    private static final long serialVersionUID = 8683452581122892189L;

    // 默认初始容量
    private static final int DEFAULT_CAPACITY = 10;

    // 空数组实例（用于空实例）
    private static final Object[] EMPTY_ELEMENTDATA = {};

    // 默认容量的空数组实例（用于默认构造函数）
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    // 存储ArrayList元素的数组缓冲区
    transient Object[] elementData; // non-private to simplify nested class access

    // ArrayList的大小（包含的元素个数）
    private int size;

    // 最大数组容量（某些VM会在数组中保留header words）
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
}
2. 构造函数
// 默认构造函数，初始化为空数组，首次添加元素时扩容为DEFAULT_CAPACITY
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);
    }
}

// 构造包含指定集合元素的列表
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}
3. add(E e) 方法
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // 确保容量足够
    elementData[size++] = e;           // 将元素添加到数组末尾
    return true;
}

// 计算最小容量并确保内部容量足够
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

// 计算所需的最小容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

// 确保明确的容量
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;  // 记录结构修改次数

    // 如果最小容量大于当前数组长度，触发扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

// 数组扩容方法
private void grow(int minCapacity) {
    // 获取旧容量
    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);
    // 调用Arrays.copyOf扩容数组
    elementData = Arrays.copyOf(elementData, newCapacity);
}

// 处理大容量需求
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}
4. add(int index, E element) 方法
public void add(int index, E element) {
    // 检查索引是否合法
    rangeCheckForAdd(index);

    // 确保容量足够
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 将index及其之后的元素后移一位
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 在index位置插入新元素
    elementData[index] = element;
    // 大小加1
    size++;
}

// 检查添加操作的索引范围
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
5. get(int index) 方法
public E get(int index) {
    // 检查索引是否合法
    rangeCheck(index);

    // 返回指定索引位置的元素
    return elementData(index);
}

// 检查索引是否越界（仅检查是否>=size）
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

// 返回索引越界的错误信息
private String outOfBoundsMsg(int index) {
    return "Index: "+index+", Size: "+size;
}

// 获取指定索引位置的元素（类型转换）
@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}
6. remove(int index) 方法
public E remove(int index) {
    // 检查索引是否合法
    rangeCheck(index);

    // 记录结构修改次数
    modCount++;
    // 获取要删除的元素
    E oldValue = elementData(index);

    // 计算需要移动的元素个数
    int numMoved = size - index - 1;
    if (numMoved > 0)
        // 将index之后的元素前移一位
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 将最后一个元素置为null，帮助GC
    elementData[--size] = null; // clear to let GC do its work

    // 返回被删除的元素
    return oldValue;
}
7. 迭代器实现
public Iterator<E> iterator() {
    return new Itr();
}

// 内部迭代器实现
private class Itr implements Iterator<E> {
    int cursor;       // 下一个要返回的元素的索引
    int lastRet = -1; // 最后一个返回的元素的索引，-1表示没有
    int expectedModCount = modCount; // 期望的修改次数，用于快速失败

    // 判断是否还有下一个元素
    public boolean hasNext() {
        return cursor != size;
    }

    // 获取下一个元素
    @SuppressWarnings("unchecked")
    public E next() {
        // 检查并发修改
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    // 检查并发修改（快速失败机制）
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
    
    // 其他方法...
}

三、关键特性分析

1. 扩容机制
  • 触发条件：元素数量超过数组容量时。
  • 扩容步骤：
    1. 计算新容量（原容量的1.5倍）。
    2. 检查是否超过最大容量（Integer.MAX_VALUE - 8）。
    3. 使用Arrays.copyOf创建新数组并复制元素。
2. 快速失败（Fail-Fast）机制
  • 通过modCount字段实现，记录结构修改次数。
  • 迭代器初始化时记录expectedModCount，每次操作前检查是否与modCount一致，不一致则抛出ConcurrentModificationException。
3. 序列化与反序列化
  • elementData被标记为transient，自定义序列化逻辑只保存实际存储的元素，而非整个数组。

四、线程安全性

  • ArrayList 是非线程安全的，多线程环境下可能出现数据不一致问题。
  • 替代方案：
    • Vector：线程安全的动态数组，所有方法使用synchronized修饰，性能较低。
    • Collections.synchronizedList：通过包装器实现同步。
    • CopyOnWriteArrayList：写时复制的线程安全列表，适用于读多写少的场景。

五、使用建议

  1. 初始容量设置

    • 预估元素数量，避免频繁扩容。例如，预计存储1000个元素，可通过new ArrayList<>(1000)指定初始容量。

  2. 避免中间插入/删除

    • ArrayList在中间插入或删除元素时需移动大量元素，效率低。如需频繁操作，建议使用LinkedList。

  3. 遍历方式选择

    • 随机访问：使用for(int i=0; i<size(); i++)效率最高。
    • 迭代器遍历：使用Iterator或foreach，支持删除操作。

六、总结

JDK 8 的 ArrayList 通过动态数组实现，支持自动扩容和随机访问，是最常用的集合类之一。理解其扩容机制、快速失败原理和性能特点，有助于在不同场景下高效使用。在多线程环境下，需使用线程安全的替代类。

Java8源码-ArrayList
潘威威的博客
08-06 1万+
今天开始学习ArrayList源码。参考的JDK版本为1.8。 相信大家对ArrayList的使用已经很熟悉了，但你真的了解ArrayList吗？ArrayList源码中注释的第一行是“Resizable-array implementation of the List interface”，意为“List接口的可变长数组实现”。ArrayList是如何实现可变长的？ArrayList有哪些私有...
图解 | 最全面的 ArrayList 源码解析 (干货满满！！！)
最新发布
小斜同学的博客
01-16 1227
在Java的集合体系中，List接口的实现类ArrayList是非常常用的容器类，比如把查询数据的结果通过ORM框架，将数据存储到ArrayList当中，下面来介绍一下ArrayList是如何实现的，注意下面所有分析均基于JDK8，不同版本可能会有差异。
ArrayList源码分析超详细
12-30 217
ArrayList源码分析超详解 想要分析下源码是件好事，但是如何去进行分析呢？以我的例子来说，我进行源码分析的过程如下几步： 找到类：利用 IDEA 找到所需要分析的类(ztrl+N查找ArraList)（此处就是 ArrayList） 新建类：新建一个类，命名为 ArrayList，将源码拷贝到该类。因为我们分析的时候肯定是需要进行代码注释，以及调试的，而jdk的源...
ArrayList源码分析（基于JDK8）
augfun的博客
09-03 7321
ArrayList简介        ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。 ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除...
JDK8 源码之ArrayList
灵小帝的博客
02-22 518
本文主要对Jdk1.8的ArrayList的源码，进行了一个细致的研读，不在于启发什么或提供新的观点，只是对于自身学习的一个总结而已！
JDK源码——ArrayList（JDK8）
MoozLee的博客
01-15 552
文章目录JDK源码——ArrayList（JDK8）1.类的定义2.常量4.成员变量5.构造方法6.普通方法——扩容6.1检查6.2扩容7.普通方法——写入8.普通方法——写出9.普通方法——删除10.普通方法——序列化11.迭代器11.1 Itr11.1.1声明11.1.2成员变量11.1.3方法11.2ListItr11.2.1声明11.2.2构造方法11.2.3普通方法11.3获取迭代器12.其他方法 JDK源码——ArrayList（JDK8） ArrayList，一个可扩容的，底层用数组实现的，非
jdk源码阅读Collection详解
08-28
在JDK源码阅读Collection详解中，我们可以看到Collection接口的实现类有很多，如ArrayList、LinkedList、HashSet、TreeSet等。这些实现类都继承了Collection接口，并实现了其定义的方法。 在实际开发中，我们经常...
JDK8中Java 8 Stream源码分析与特性详解
标题“java8stream源码-InJDK8:在JDK8”明确指出该资源聚焦于 JDK 8 中 Stream 特性的源码实现，结合描述中提到的“Java8 特性示例，包含 Java 文档和一些单元测试”，可以推断出该压缩包内容极有可能是一个开源项目...
Java 集合—— ArrayList 源码分析
weixin_44814196的博客
08-22 1039
分析 ArrayList 的底层数据结构和扩容机制。
SpringBoot 3.0与JDK 17新特性详解及可运行源码
压缩包中的源码示例应充分展示了上述特性的具体应用场景，如使用record定义REST接口参数、用var简化服务层逻辑、通过文本块构建邮件模板等内容，帮助学习者快速掌握如何在真实项目中落地这些先进特性，进而推动整个...
JDK8源码学习笔记之一：ArrayList
zhuzhenxi555的博客
11-25 377
分析了JDK中ArrayList的源码及注释，总结了使用ArrayList时的注意事项。
ArrayList源码学习（JDK8）
hongwei_dai的博客
02-20 356
本文是配合部分源码分析的，若有错误之处，欢迎大家指出，共同学习，共同进步，谢谢！（ps：翻译不到位的地方大家忽略 ==、）废话不多说，咱们直接开始！ 进入ArrayList类，大致看看上面描述： /** Resizable-array implementation of the &lt;tt&gt;List&lt;/tt&gt; interface. Implements * al...
ArrayList源码分析 JDK8
java_tjx的博客
03-18 378
ArrayList基本概念ArrayList是一个数组实现的列表，容量自动增长，线程不安全。RandomAccess接口，用于标记当前类是可以随机访问的，当一个类标记了RandomAccess接口，那么表明该类使用for循环遍历效率更高，如果没用RandomAccess标记，则使用迭代器遍历效率更高。Cloneable接口，即覆盖了函数clone()，能被克隆。Serializable接口，支持序...
ArrayList详解（基于JDK8）
达尔文的猹的博客
05-08 991
文章目录ArrayList要点ArrayList类API源码分析1. 基本属性2. 初始化3. 添加元素4. 获取元素5. 更新元素6. 基本方法7. 序列化8. 删除元素9. **迭代与删除**Fail-Fast 机制1. 概述2. **避免fail-fast**Arrays.asList()线程安全参考资料 ArrayList 要点 ArrayList 内部使用动态数组实现元素存储。并允许...
ArrayList 源码详解 (JDK8)
赵丙双的博客
06-07 323
文章目录类图声明RandomAccess 接口Cloneable 接口Serializable 接口List 接口AbstractList 抽象类属性DEFAULT_CAPACITYEMPTY_ELEMENTDATADEFAULTCAPACITY_EMPTY_ELEMENTDATAelementDatasize构造方法方法trimToSize()容量计算、扩容size()、isEmpty() 、 contains(Object o) 、indexOf(Object o)、lastIndexOf(Object
JDK8 ArrayList源码解析
心轨羽的博客
04-09 261
1.属性及构造方法 /**序列化id**/ private static final long serialVersionUID = 8683452581122892189L; /**初始容量**/ private static final int DEFAULT_CAPACITY = 10; /** * 空对象 */ private s
ArrayList源码深度解析（JDK8）【重点】
sunnyday0426的博客
02-22 1059
ArrayList源码深度解析概述构造方法ArrayLIst 常用API新增boolean add(E e)方法void add(int index, E element)方法结语   同学们，今天我们一起来了解最常用集合ArrayList的源码，通过本文的学习，你将能够了解到看源码的思路，以及掌握ArrayList的源码知识。 概述   简要的说，ArrayList是一个动态数组，他不是线程安全的，允许存储null元素，它的底层数据结构依然是数组，ArrayList是List接口的大小可变数组的实现；Ar
jdk8下ArrayList源码分析实现原理
Tiglle的博客
03-05 363
1.ArrayList 继承抽象类AbstractList 实现接口RandomAccess、Cloneable、Serializable 2.ArrayList的初始化 ArrayList的构造函数有3个，通过new出这三个构造函数即可得到ArrayList实例 那么这三个构造函数初数化的时候都做了什么操作呢？有什么区别呢？ 先看看无参构造函数源码 其中有两个属性：elementData和DEFAULTCAPACITY_EMPTY_ELEMENTDATA，来看看定义： 可以看到，elementDa
Java集合详解(含JDK8源码)
qq_62767608的博客
03-29 4555
Java集合底层源码讲解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值