ArrayList的扩容机制

在Java中，ArrayList是一个使用非常频繁的集合类型，它的底层是Object数组，所以它拥有数组所拥有的特性，比如支持随机访问，所以查询效率高，但插入数据需要移动元素，所以效率低。

先来看看若是调用ArrayList的无参构造方法，会发生什么？

transient Object[] elementData;

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
 

在构造方法中，它将DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值给elementData，这个DEFAULTCAPACITY_EMPTY_ELEMENTDATA是一个空的Object数组，而elementData就是ArrayList实际存储数据的容器。

由此可知，ArrayList在调用无参构造方法时创建的是一个长度为0的空数组，当调用add()方法添加元素时，ArrayList才会触发扩容机制：

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

  

 

  
1
  
2
  
3
  
4
  
5
 

add()方法的第一行即是执行扩容流程：

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

  

 

  
1
  
2
  
3
 

该方法又会先计算扩容容量：

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

  

 

  
1
  
2
  
3
  
4
  
5
  
6
 

初始elementData就是一个空数组，条件成立，它会从DEFAULT_CAPACITY和minCapacity中选择一个最大值返回，其中DEFAULT_CAPACITY表示默认的初始容量，它的值为10：

private static final int DEFAULT_CAPACITY = 10;

  

 

  
1
 

而minCapacity是add()方法传递过来的，值为size + 1：

ensureCapacityInternal(size + 1);  // Increments modCount!!

  

 

  
1
 

所以calculateCapacity()方法将返回10，之后调用ensureExplicitCapacity()方法：

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
 

首先让modCount++，这是用来记录数组被修改次数的变量，我们先不管它，此时minCapacity的值为10，elementData.length的值为0，条件成立，执行grow()方法：

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
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
 

注意这一行代码：

int newCapacity = oldCapacity + (oldCapacity >> 1);

  

 

  
1
 

先将旧容量右移1位，再加上旧容量就得到了新容量，正数右移1位相当于除以2，在该基础上加旧容量，则等价于新容量 = 旧容量 * 1.5，所以才有ArrayList每次扩容为旧容量的1.5倍的说法，最后调用Arrays.copyOf()方法进行拷贝，并将elementData指向新数组，而旧数组因为没有引用指向它，很快就会被垃圾收集器回收掉。

当第二次调用add()方法时，程序依然要走到扩容方法：

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

  

 

  
1
  
2
  
3
  
4
  
5
  
6
 

但此时的elementData已经不是空数组了，所以直接返回当前size + 1，即：2，接着调用：

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
 

因为此时minCapacity小于数组长度，所以if判断不会成立，也就不会发生扩容。

当添加第11个元素时，ArrayList应该会触发第二次扩容，来看源代码：

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

  

 

  
1
  
2
  
3
  
4
  
5
  
6
 

minCapacity的值为11，紧接着调用它：

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
 

此时minCapacity的值大于elementData的长度，条件成立，触发扩容机制：

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
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
 

将原容量10右移一位得到5，再加上原容量10得到15，所以新数组的容量为15，最后对数组进行拷贝扩容就完成了。

当ArrayList进行第三次扩容后容量会是多少呢？我们知道，新容量一定是旧容量的1.5倍，而15 * 1.5 = 22.5，那么新容量到底是22还是23呢？所以，如果你只知道新容量是旧容量的1.5倍，这个问题你就无法知道。事实上，ArrayList底层是通过移位操作计算得到的新容量。所以新容量应该等于15 >> 1 + 15 = 22，由此可得，ArrayList经过第三次扩容后容量为22。

然而在addAll()方法中，扩容机制会有一定的变化，比如：

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.addAll(Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
}

  

 

  
1
  
2
  
3
  
4
 

执行完addAll()方法后，ArrayList的容量应该是多少呢？是15吗？来看看源代码：

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
 

它将调用ensureCapacityInternal()方法进行扩容，并传入 size + numNew = 11：

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

  

 

  
1
  
2
  
3
  
4
  
5
  
6
 

因为初始elementData是一个空数组，符合条件，所以它将返回DEFAULT_CAPACITY和minCapacity中较大的那个，结果是minCapacity较大，所以返回11，这就导致addAll()方法执行结果后ArrayList的容量为11。

addAll()方法总是选择扩容一次后的容量与旧容量加上添加的元素个数的容量中取一个最大值作为新的容量，比如：当前ArrayList中有10个元素，而addAll()方法需要添加6个元素，当ArrayList触发扩容后的新容量应该为15，而旧容量加上需要添加的元素容量为16，从中取一个较大值为16，所以新容量应该为16。

文章来源: blizzawang.blog.csdn.net，作者：·wangweijun，版权归原作者所有，如需转载，请联系作者。

原文链接：blizzawang.blog.csdn.net/article/details/122099920