探究ArrayList初始化值对性能的影响 | ArrayList扩容原理 | ArrayList源码

要想知道初始化值对性能是否有影响，首先需要了解ArrayList的底层初始化、添加元素、扩容的原理

构造函数

ArrayList有三个构造函数：

• 无参构造函数

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

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

无参构造函数构造的ArrayList是一个空的Object[]数组。

• int参数构造函数

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

参数为ArrayList的初始化容量initialCapacity，如果initialCapacity为0，则构建一个空的Object[]数组（和无参构造函数一样），如果initialCapacity > 0，initialCapacity即为Object[]数组的大小。

• 集合构造函数

public ArrayList(Collection<? extends E> c) {
    Object[] a = c.toArray();
    if ((size = a.length) != 0) {
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            elementData = Arrays.copyOf(a, size, Object[].class);
        }
    } else {
        // replace with empty array.
        elementData = EMPTY_ELEMENTDATA;
    }
}

总结来说，即复制传入的集合。扩容对性能的影响主要集中在此。

ArrayList.add添加方法

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    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 static final int DEFAULT_CAPACITY = 10;

add方法首先调用ensureCapacityInternal方法，计算list成功添加当前元素所需要的容量。如果未指定初始容量且首次添加元素时，则默认需要的容量为10。

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

如果需要的容量大于当前Object[]数组的最大容量，则调用grow方法进行扩容。

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 容量扩大为原来的1.5倍
    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);
}

int newCapacity = oldCapacity + (oldCapacity >> 1); 可以看出，每次扩容时，容量都会扩大为原来的1.5倍。如果扩容后容量依然不够，则扩容至需要的容量（第一次扩容，原始数组为空，而需要的minCapacity为DEFAULT_CAPACITY，即10）。

扩容后调用Arrays.copyOf进行数组复制。

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e; // 添加元素到数组末尾
    return true;
}

回到add方法，将待添加元素添加到数组末尾，并返回true

add方法流程图

ArrayList.clear方法

public void clear() {
    modCount++;
    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;
    size = 0;
}

clear方法即将原数组所有元素置为null，size置为0，操作数不置0，依然+1。

ArrayList.trimToSize方法

public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    }
}

即将ArrayList容量调整为实际的元素数量，从而去除多余的容量，但通常不会手动执行这个方法。

测试初始化容量对性能的影响

循环往List<String>中添加一亿个元素，比较List<String> = new ArrayList(); 和 List<String> = new ArrayList(100000000);所需要的时间。

private static final int BATCH_SIZE = 10000000;
@GetMapping("/test1")
public void test1() {
    long l = System.currentTimeMillis();
    ArrayList<String> list = new ArrayList<>();
    for (int i = 0; i < 100000000; i++) {
        list.add(getBigString());
        if (list.size() % BATCH_SIZE == 0) {
            System.out.println(list.size() + " 耗时：" + (System.currentTimeMillis() - l));
        }
    }
}
@GetMapping("/test2")
public void test2() {
    long l = System.currentTimeMillis();
    List<String> list = new ArrayList<>(100000000);
    for (int i = 0; i < 100000000; i++) {
        list.add(getBigString());
        if (list.size() % BATCH_SIZE == 0) {
            System.out.println(list.size() + " 耗时：" + (System.currentTimeMillis() - l));
        }
    }
}
private String getBigString() {
    return "testTestTestTestTestTestTestTestTestTestTestTestTestTest" +
            "testTestTestTestTestTestTestTestTestTestTestTestTestTest" +
            "testTestTestTestTestTestTestTestTestTestTestTestTestTest" +
            "testTestTestTestTestTestTestTestTestTestTestTestTestTest" +
            "testTestTestTestTestTestTestTestTestTestTestTestTestTest"; // 或者更大
}

test1和test2方法唯一区别即初始容量不同。

• 不指定初始化容量：

大多数情况下耗时在3600ms左右，少数情况下会出现明显卡顿导致耗时增加。

• 指定初始容量为1亿：

测试多次，耗时非常稳定，在2500ms左右。

• 加一组初始化容量为3千万的对照组：

耗时平均在2800ms-3100ms之间，比1亿组慢，比初始不指定容量要快一点。

总结

经过三种场景下的对比，可以看出，ArrayList的频繁扩容，对性能会产生一定的影响。

所以在能够大致确定数组最大容量的前提下，手动设置初始容量会更好（如解析大量文件，并批量插入到数据库中，且批量插入的最大值确定）。

如果不确定数组究竟需要添加多少元素且数据量不大的情况下，那么不指定容量也不会对性能产生多大的影响。