【Java】JDK 1.8 ArrayList扩容原理

关注

原创最新推荐文章于 2026-07-06 08:18:01 发布 624 阅读 AI 写同款· GEO 优化 ›

Python+Appium实现泛微OA自动打卡：5分钟搭建移动端自动化脚本移动端自动化测试是软件测试与办公自动化领域的重要技术方向，其核心原理是通过程序模拟用户对手机应用界面的操作，实现重复性任务的自动执行。Appium作为主流的开源移动端自动化框架，基于WebDriver协议，支持跨平台且无需修改被测应用，为自动化脚本开发提供了标准化接口。在工程实践中，结合Python简洁的语法和丰富的生态，可以快速构建稳定可靠的自动化解决方案。这一技术组合的价值在于能够高效处理“重复性、低价值、高频率”的日常操作，例如考勤打卡、数据填报等办公场景，显著提升工作效率。本文以泛微OA Emobi 阅读详情

两个构造器

ArrayList的以下属性，跟扩容有关。

//无参构造时，初始容量大小
private static final int DEFAULT_CAPACITY = 10;
//存放ArrayList元素的数组
transient Object[] elementData;
//ArrayList的大小
private int size;
//传参为0时构造的数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//无参构造时的“空”数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

ArrayList一共有三个构造器，这里主要提到前两个，即无参的和传入一个整数的构造器。

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_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);
    }
}

有参的也很简单，传入的参数大于0时，创建一个新的Object数组。等于0时，将EMPTY_ELEMENTDATA赋给元素数组，小于0时，直接抛异常。

这两种方式创建的ArrayList在扩容的时候，会有细微的区别。

以下源码基于JDK 1.8。

使用无参构造器的扩容机制

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

执行add方法，首先会调用ensureCapacityInteral(int minCapacity)方法。

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

这个方法的参数是minCapacity，最小容量，此时minCapacity=size+1=0+1=1。这个方法又会调用ensureExplicitCapacity(int minCapactiy)方法。在这之前会调用calculateCapacity(elementData, minCapacity)方法，利用其返回值。

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

这个方法，传入的参数是elementData和minCapactiy，如果数组是由无参构造器建造的，那么就返回默认数组大小DEFAULT_CAPACITY和当前最小容量minCapacity的较大值。此时minCapacity=1，默认为10，所以返回的是10。

所以，当由无参构造器构造时，如果minCapacity<10，就返回10；大于10，则返回minCapacity，也就是当前容量+1（即size+1）。

而有参构造器构成时，总是返回minCapacity，也即（size+1）。

那么此时ensureExplicitCapacity方法的入参，就是10，

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
    	grow(minCapacity);
}

由于执行了添加操作，所以modCount++（这个参数在迭代器的hasNext()和next()会用到，可能会抛出ConcurrentModificationException），接着判断minCapacity和当前数组长度的关系，此时minCapacity=10，数组长度为0，minCapacity-element.length>0，所以要执行grow(int minCapacity)方法，对数组进行扩容。

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);
}

oldCapacity=0，newCapacity=oldCapacity*1.5还是=0，所以newCapacity-minCapacity=0-1<0，把newCapacity设置为minCapacity，然后调用Arrays.copyOf方法，将原数组扩容至newCapacity，也就是10。

最后通过elementData[size++] = e，完成添加，此时size=1。

第2次（一直到第10次）添加的时候，还是先调用ensureCapacityInteral(size+1)，此时传入的参数为2。

然后调用calculateCapacity(elementData, minCapacity=2)，2<默认值10，还是返回10。

在ensureExplicitCapacity中，由于此时数组的容量是10，而10-10=0，所以不执行grow方法。

那么直接就是elementData[size++] = e，size=2。

第11次添加的时候，依然调用ensureCapacityInteral(size+1)，此时传入的参数是11。

然后调用calculateCapacity(elementData, minCapacity=11)，11>默认值10，返回11。

在ensureExplicitCapacity中，由于此时数组的容量是10，而11-10>0，所以又要进行扩容了。

grow方法，此时传入的参数是11，oldCapacity是10，newCapacity是15，newCapacity-minCapacity=4>0，直接复制数组，长度由10增加到15，最后完成添加。

此后以此类推。