Java面试重点--证明采用ArrayList有参构造器的扩容机制

上一篇链接：Java面试重点–ArrayList 底层结构和证明采用Arraylist无参构造器的扩容机制

采用ArrayList有参构造器的扩容机制结论

1、ArrayList的底层结构是一个Object[] elementData，即一个Object类型的数组。
2、如果采用的是有参构造器，则数组初始空间为传入的参数值，如需再次扩容，则扩容至原数组空间的1.5倍。

ArrayList 底层源码分析

证明采用Arraylist无参构造器的扩容机制

在ArrayList中加入20个元素，数组初始空间为8。

import java.util.ArrayList;

public class Arraylist_ {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList(8);
        for (int i = 1; i <= 20; i++) {
            arrayList.add(i);
        }
        System.out.println(arrayList);
    }
}

添加第9个元素

1、Debug进入arrayList.add(i)；

    public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
    }

i = 9，所以e = 9。modCount = 9，size = 8。
2、Debug进入add(e, elementData, size);
e = 9，s = 8，因为数组初始空间为8，所以elementData.length = 8，所以满足s == elementData.length。

    private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }

3、Debug进入grow()
size = 8

    private Object[] grow() {
        return grow(size + 1);
    }

4、Debug再次进入grow()
minCapacity = size + 1 = 9，elementData.length = 8，所以oldCapacity = 8，所以满足if条件，进入if语句。
oldCapacity = 8，minCapacity - oldCapacity = 1，oldCapacity >> 1 = 4

    private Object[] grow(int minCapacity) {
        int oldCapacity = elementData.length;
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth */
                    oldCapacity >> 1           /* preferred growth */);
            return elementData = Arrays.copyOf(elementData, newCapacity);
        } else {
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }

5、Debug进入newLength方法
oldLength = 8，minGrowth = 1，prefGrowth = 4，所以newLength = prefGrowth + oldLength = 12，满足if条件，返回12，所以newCapacity = 12。

    public static int newLength(int oldLength, int minGrowth, int prefGrowth) {
        // assert oldLength >= 0
        // assert minGrowth > 0

        int newLength = Math.max(minGrowth, prefGrowth) + oldLength;
        if (newLength - MAX_ARRAY_LENGTH <= 0) {
            return newLength;
        }
        return hugeLength(oldLength, minGrowth);
    }

6、返回grow()方法，执行return elementData = Arrays.copyOf(elementData, newCapacity);，进行数组的拷贝，所以elementData数组扩容至12，所以证明了创建ArrayList对象时，如果采用的是有参构造器，如需再次扩容，则扩容至原数组空间的1.5倍。