jdk源码阅读一：ArrayList

最新推荐文章于 2025-10-27 21:18:07 发布
原创 最新推荐文章于 2025-10-27 21:18:07 发布 · 550 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文详细介绍了Java中ArrayList的工作原理，包括其内部实现、容量扩展策略、常用方法解析等内容，并深入探讨了迭代器实现及其特性。

ArrayList介绍

这里写图片描述
ArrayList是我们使用的最多的集合类了。特点主要如下：

  • 基于数组实现底层存储，容量可以自动扩展。
  • 实现List全部接口。
  • 允许null对象
  • 提供操作数组容量大小的方法。
  • 粗略来看和Vector类相同，但是 Vector在 方法上加了同步，所以Vector是线程安全的。
  • size，isEmpty，get，set，iterator和listIterator运行时间为常量。
  • add方法 如果添加n个元素 时间复杂度O(n)
  • ArrayList非 thradsafe，所以自己wrap或者用Collections#synchronizedList
  • 返回的iterator是fail-fast，如果iterator创建后，修改了list结构则会抛出异常ConcurrentModificationException，
    注意这里异常表明是一个bug，需要避免，而不能处理业务逻辑。

size 变量

size 表示当前list中存储了元素的个数，初始化为0。add一个元素加一，删除一个元素减一。

capacity(容量)增长策略

每个ArrayList示例都有一个capacity。表示数组（list中用来储存元素）的大小。

capacity至少和size相等，不会小于它。capacity大小是自动增长的。你也可以调用ArrayList#ensureCapacity方法改变容量。
不过如果你将容量改小 是不起作用的，ensureCapacity方法不允许。

增长容量的方法有三个。

这里写图片描述

ensureCapacity

` /**
 * Increases the capacity of this <tt>ArrayList</tt> instance, if
 * necessary, to ensure that it can hold at least the number of elements
 * specified by the minimum capacity argument.
 *
 * @param   minCapacity   the desired minimum capacity
 */
public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        // any size if not default element table
        ? 0
        // larger than default for default empty table. It's already
        // supposed to be at default size.
        : DEFAULT_CAPACITY;

    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}`

说明：

  • public的，说明是提供给用户操作的，因为其他两个方法是private的。这个方法Arraylist内部是没有调用的。内部扩容调用的是ensureCapacityInternal方法。
  • 增加容量如果有必要：原则就是判断minCapacity 和当前的capacty大小，如果大则增加。
  • minExpand（最小扩展容量）可能是0 ，也可能是DEFAULT_CAPACITY=10。
  • 一般ensureCapacity类型的三个方法只是确保最小容量满足，但是真正的增长策略可能不同，比如add一个元素，minCapacity=size+1。
    这时候如果需要扩容(minCapacity>size)那么数组只需要增大1，即可，但是这样后面每次都要复制，所以后面真正讲到的grow方法策略不是+1，而是然后大小增加150%。

源码分析：

  • minExpand表示最小拓展容量

首先我们看下ArrayList创建的两种创建方法和他的两个常量

ArrayList arr = new ArrayList<>();
ArrayList arr = new ArrayList<>(0);

 /**
 * Shared empty array instance used for empty instances.
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * Shared empty array instance used for default sized empty instances. We
 * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
 * first element is added.
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

如果使用第一种创建方法那么this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

如果使用第二种创建方法 则this.elementData = EMPTY_ELEMENTDATA;

什么意思？就是说如果你没穿参数，那么Arraylist 设置 默认空数组。如果你传了个0，则认为是你故意设置容量为0的。它用上面两个常量来区分这种行为，区分的目的在于对待这两种不同的空数组， 第一次的容量增长策略不同。

下面我们接着说ensureCapacity方法，就好解释多了，如果elementData！=DEFAULTCAPACITY_EMPTY_ELEMENTDATA 那么minExpand最小扩展容量=0，如果否则minExpand = DEFAULT_CAPACITY=10。

  • 委托给ensureExplicitCapacity方法，扩容

然后比较传入参数和minExpand的大小。取其中大者。然后委托给ensureExplicitCapacity方法。

ensureExplicitCapacity

`private void ensureExplicitCapacity(int minCapacity) {
    //修改次数 计数器 在iterator迭代出现并发修改快速失败就是利用到该字段
    modCount++;

    // overflow-conscious code
    // 如果minCapacity大于数组长度则扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}`

grow方法是真正的增长策略方法：

/**
 * Increases the capacity to ensure that it can hold at least the
 * number of elements specified by the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 */
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

方法说明：
1. newCapacity先扩展到为原来的1.5倍。
2. 比较newCapacity和minCapacity选择大的。
3. newCapacity如果超过MAX_ARRAY_SIZE（= Integer.MAX_VALUE - 8），则调用hugeCapacity，增大到Integer.MAX_VALUE。
4. 调用Arrays.copyOf调整elementData到新容量。

ensureCapacityInternal

  private void ensureCapacityInternal(int minCapacity) {
    //如果满足elementData是默认空数组，则比较 minCapacity和DEFAULT_CAPACITY 取大者
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

到此容量增长策略已经分析完成。

扩容方法总结：

  1. ensureCapacity是public给开发人员调用的api，内部是没有调用的。
  2. ensureCapacityInternal才是内部判断是否需要扩容的方法。
  3. 上面两个方法都是调用ensureExplicitCapacity实现。
  4. ensureCapacityInternal和ensureExplicitCapacity是私有的。
  5. 这三个方法是判断是否需要扩容，但是不一定真正执行扩容动作，真正的方法是grow。
  6. 如果我们能够提前预知list容量 直接赋值容量，可以减少后面自动扩容导致的数组复制的开销，调用ensureCapacity直接到一个比较大的容量也是可行的。

List常用方法分析

这里写图片描述

插入元素

顺序插入add(E e)

   public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

确保容量加1,然后直接数组赋值。时间复杂度O(1)。

随机插入

public void add(int index, E element) {
    //检查index是否在 0-size范围内
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

因为是随机插入，所以要把插入位置index以及以后的元素向后移动一位。所以速度会慢些。

插入集合addAll

这里不再细讲，大致思路是将Collection转成数组然后插入数组。不过如果是随机插入容量足够 还是复制了两次（第一次向后移动n位，第二次赋值Collection 到指定位置）。

clear清空

很简单 循环将数组设置null

检索操作

主要包括contains，containsAll，indexOf，lastIndexOf。

containsAll循环调用的contaions，contaios调用的indexOf。
indexOf和lastIndexOf差不多，一个从数组顺序查找，一个从数组逆序查找。我们主要看下lastIndexOf。

public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

方法也很简单，但是时间复杂度还是非常高的，平均O(n*n)。

get 随机获取元素

速度很快O(1)，会先检查index是否合法[0,size)。

remove方法

有四个，根据元素删除，需要遍历数组，找到位置，然后移动数组。根据index删除，直接移动数组。效率都不高。

removeIf是1.8新加的，根据传入lambda 表达式判断是否删除元素，会应用于每个元素，内部通过迭代器遍历元素，判断是否需要该元素。

迭代器

有iterator，listiterator 和Spliterator。

  1. iterator主要通过内部类实现，存储了一个cursor，默认无参的=0。
  2. listiterator继承了iterator，实现了可以向前遍历。
  3. Spliterator（splitable iterator可分割迭代器）接口是Java为了并行遍历数据源中的元素而设计的迭代器，这个可以类比最早Java提供的顺序遍历迭代器Iterator，但一个是顺序遍历，一个是并行遍历。

可以参考：https://segmentfault.com/q/1010000007087438

iterator分析

public Iterator<E> iterator() {
    return new Itr();
}

是ArrayLIst一个内部类，截取部分代码：

 private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        //每次都会检查modCount是否改变，改变则抛出异常
        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];
    }

listiterator分析

 private class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {
        super();
        cursor = index;
    }

    public boolean hasPrevious() {
        return cursor != 0;
    }

    public int nextIndex() {
        return cursor;
    }

    public int previousIndex() {
        return cursor - 1;
    }

    @SuppressWarnings("unchecked")
    public E previous() {
        checkForComodification();
        int i = cursor - 1;
        if (i < 0)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i;
        return (E) elementData[lastRet = i];
    }

部分代码如上，继承了Itr，添加了逆序遍历功能。

子列表

通过一个内部类实现，部分代码如下：

 private class SubList extends AbstractList<E> implements RandomAccess {
    private final AbstractList<E> parent;
    private final int parentOffset;
    private final int offset;
    int size;

看出来 主要通过一个offset变量来记录开始位置在数组中的起始位置，还是共享父类的数组。

序列化、反序列化

ArrayList实现了Serializable接口，所以它支持序列化，但是我们看到底层存储：

 transient Object[] elementData; // non-private to simplify nested class access

又是transient，表示忽略该字段的序列化，其实他是通过writeObject(java.io.ObjectOutputStream s)，readObject(java.io.ObjectInputStream s)两个方法重写实现的。注意这两个方法是固定写法。以write为例：

 private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
    // Write out element count, and any hidden stuff
　//记录当前修改次数　
    int expectedModCount = modCount;
    //写入类元信息和非静态成员和非transient成员
    s.defaultWriteObject();
    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }
    //如果序列化过程中发现有修改list结构 则抛出异常

    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

上面代码中写了两次size,网上说是兼容老板ｊｄｋ原因。还提到反序列化老版本会恢复容量　新版本只恢复ｓｉｚｅ大小的容量。
具体参考：
http://mushanshitiancai.github.io/2016/06/17/java/language/JDK%E6%BA%90%E7%A0%81%E9%98%85%E8%AF%BB-ArrayList/#序列化-反序列化

克隆

克隆只是浅拷贝。元素对象还是共享的。

其他总结

用的最多的移动数组方法是Arrays.copyOf和 System.arraycopy。

pdf下载

这里写链接内容

ArrayList的源码解析（含详细注释）
SIESTA030的博客
01-24 584
ArrayList的源码自学 1、今日阅读部分 1.1、五个重要参数 DEFAULT_CAPACITY（集合默认容量大小）。 EMPTY_ELEMENTDATA（用于空实例的共享空数组实例）。 DEFAULTCAPACITY_EMPTY_ELEMENTDATA（共享的空数组实例用于默认大小的空实例）。 elementData（arraylist 中存数据的地方）。 size（数据元素个数）。 * Default initial capacity. * 集合的默认容量为10
ArrayList的源码分析
Keep Learning
07-15 436
ArrayList使用的存储的数据结构ArrayList的初始化ArrayList是如何动态增长ArrayList如何实现元素的移除ArrayList小结 ArrayList是我们经常使用的一个数据结构，我们通常把其用作一个可变长度的动态数组使用，大部分时候，可以替代数组的作用，我们不用事先设定ArrayList的长度，只需要往里不断添加元素即可，ArrayList会动态增加容量。ArrayLis...
[Java] ArrayList源码阅读分析
qfchenjunbo的博客
11-12 159
1.1 ArrayList介绍 ArrayList一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。 ArrayList继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。ArrayList实现了RandmoAccess接口，即提供了随机访问功能。RandmoAcc...
ArrayList函数及相关解释(一)
hongbochen1223的专栏
08-14 1671
Java中ArrayList是使用对象数组实现的，默认的数组容量为10。在ArrayList中，默认创建了两个空的对象数组，一个用户该对象的空实例，一个用于当第一个元素被添加的时候，该数组要被填充多少。 同时，该类中还有一个transient属性的对象数组，transient描述的对象属性，表示在序列化的时候，不用去序列化该属性。 1、ArrayList构造函数 首先我们看一下ArrayList的构造函数，该类有三个构造函数，分别是： ArrayList(int initialCapacity) Arra
ArrayList源码解析
a219219219219的博客
12-12 311
前言 集合中的collection接口下的常用类的关系 ArrayList中的成员变量 /** * Shared empty array instance used for empty instances. */ private static final Object[] EMPTY_ELEMENTDATA = {};/** * Shared empty array instance used for default sized empty instances. We * di...
3.jdk源码阅读之ArrayList(上)
前端、移动端、后端源码级底层原理分享
07-11 1213
我个人认为看代码不应该流水账一般的看，而应该带着问题去看。换个说法就是你想通过阅读源码解答你心中什么疑问？回到jdk源码，ArrayList应该是java程序员日常开发中用的比较多的类。有以下几个问题，我觉得可以从源码中找到答案：1.当向ArrayList中添加元素的时候，如果容量不够了，它是怎么扩容的？什么时候扩容？扩到多大？2.我们都知道ArrayList线程不安全，那是什么导致的线程不安全呢？3.ArrayList底层是通过什么数据结构来实现的？
JDK源码阅读篇——持续更新
最新发布
weixin_44840369的博客
10-27 1957
默认扩容为旧容量的 1.5 倍；若 1.5 倍仍不够，直接用所需最小容量；若超过最大限制，用或抛出 OOM；最后通过数组拷贝完成扩容。LinkedList 通过Node的prevnext指针实现双向链表，通过firstlast指针快速定位头尾，实现高效增删。增删快：仅修改指针，无需移动元素（已知节点时 O(1)）。查询慢：无下标，需遍历节点（O(n)）。要不要我帮你整理一份JDK 核心类源码阅读重点笔记？笔记会提炼每个类的核心逻辑、关键方法和面试高频考点，方便你快速复习和查阅。
JDK源码阅读顺序
热门推荐
猴子哥哥的博客
03-15 6万+
很多java开发的小伙伴都会阅读jdk源码，然而确不知道应该从哪读起。以下为小编整理的通常所需阅读的源码范围。 标题为包名，后面序号为优先级1-4，优先级递减 1、java.lang 1) Object 1 2) String 1 3) AbstractStringBuilder 1 4) StringBuffer 1 5) StringBuilder 1 6) Boolean 2 7) B...
我是如何阅读JDK源码的？
WriteOnRead
10-07 1180
1. 前言 之前断断续续读过一部分 JDK 常用类的源码，这里想把过程中的一些心得和方法记录下来，如果能帮到需要的小伙伴就再好不过了！本文主要分享一下我的阅读工具和阅读顺序。PS: 由于...
关于ArrayList源码的一些自我理解以及解析（一）：ArrayList的两种不同“空数据”
GhostPaints的博客
02-13 822
在首先进入ArrayList源码的时候，看到的先是它的继承关系，ArrayList一定是其他类的子类，而它的父类就是AbstractList&lt;E&gt;。 public class ArrayList&lt;E&gt; extends AbstractList&lt;E&gt; implements List&lt;E&gt;, RandomAccess, Cloneable, java...
ArrayList详解
Valineliu
03-11 4万+
1、简介 ArrayList是Java集合框架中的一个重要的类，它继承于AbstractList，实现了List接口，是一个长度可变的集合，提供了增删改查的功能。集合中允许null的存在。ArrayList类还是实现了RandomAccess接口，可以对元素进行快速访问。实现了Serializable接口，说明ArrayList可以被序列化，还有Cloneable接口，可以被复制。和Ve
ArrayList扩容机制
qq_41345281的博客
09-04 591
在这之前首先看一下ArrayList的主要参数 private static final long serialVersionUID = 8683452581122892189L; /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10; /** * Shared empty array instance used for empty instances. */ private stati
分析java.util.ArrayList的内存分配
ALLYLAI的博客
12-21 2301
看源码：java.util.ArrayList.class文件，进行分析： /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10;//默认的初始化数组长度默认是10 /** * Shared empty array instance
ArrayList动态扩容机制--源码解析
Yanliang
01-07 507
阅读原文 ArrayList动态扩容机制–源码解析 /** * Default initial capacity. * 默认容量大小 */ private static final int DEFAULT_CAPACITY = 10; /** * Shared empty array instance used for empty instances. * 空对象数...
ArrayList源码分析（基于JDK8）
Fighter168的专栏
03-12 2万+
ArrayList 源代码解读,以及ArrayList特点总结
JDK8之ArrayList源码
weixin_30919571的博客
06-02 121
ArrayList三个构造器 /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10; //初始化容量大小 /** * Shared empty array instance used for empty inst...
ArrayList扩容源码解读
u011101498的专栏
09-22 474
1.  ArrayList的构造方法，源码如下： 1/**2     * Shared empty array instance used for default sized empty instances. We3     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when4  
Java源码之ArrayList
walker lee
12-21 2395
Java源码之ArrayList 转载请注明出处：http://blog.csdn.net/itismelzp/article/details/50371326 一、ArrayList概述 ArrayList就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素，实现了ICollection和IList接口，灵
ArrayList源码解析(jdk1.8)——思路篇（如何看源码）
Gavin_Java_的博客
06-23 2981
前言：关于ArrayList相信大家都不陌生。而且大多数人应该都点开过它的源码浏览过。不过看到了什么，记住了什么，这是个值得深思的问题。博主今天写这篇文章的重点也不是解析其源码。更多的是想和大家分享一下看源码的一种方法以及一种思路。 源码解析第一步：简单了解其特性 ArrayList特点： ArrayList是有序的（放入顺序） ArrayList元素是不唯一的（可存放重复元素） ArrayList简介： ArrayList底层是由数组实现的 他的容量是动态增长的 操作元素时查询效率高，增删效
ArrayList扩容源码分析
咔咔学长
03-07 369
一、前言 我们都知道ArrayList底层是用一个数组来存储对象的，但是数组的长度是不可变的。当数组内的空间用完之后，ArrayList是如何扩容（即扩大数组长度）的？什么时候开始扩容的？本章就来探讨下这些问题。 二、关键属性 1. 存储数据的数组：Object[] elementData /** * The array buffer into which the element...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值