ArrayList的扩容机制

​

ArrayList

List接口的可调整大小的数组实现。 实现所有可选列表操作，并允许所有元素，包括null 。 除了实现List接口之外，该类还提供了一些方法来处理内部用于存储列表的数组的大小。

ArrayList的变量

//添加元素时，如果添加后长度低于10，就将elementData长度扩到10
private static final int DEFAULT_CAPACITY = 10;

//单参ArrayList(int initialCapacity)创建对象，并且参数为0,让elementData等于该空数组
private static final Object[] EMPTY_ELEMENTDATA = {};

//空参构造创建对象时，让elementData等于该空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

transient Object[] elementData;//存放数据

private int size;//存放数据的长度

ArrayList的构造方法

空参构造

初始化elementData为空数组

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

单参（int）构造

如果参数initialCapacity大于0，给elementData 初始化为长度为initialCapacity的数组；若等于0，初始化为一个长度为0的数组；若小于0则抛出异常

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

单参（Collection）构造

传入容器参数，将c容器内的内容赋值给elementData，如果c无内容，则将一个空数组赋值给elementData,同事初始化数组长度size

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

ArrayList的add方法

进入add方法

先执行ensureCapacityInternal确保数组elementData的容量足够，再将e添加进elementData

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

进入ensureCapacityInternal方法，其中calculateCapacity方法返回elementData需要的最低长度，该整数作为参数传入ensureExplicitCapacity方法中，用于判断是否需要扩容

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

进入calculateCapacity方法，如果elementData 为空，则返回max(10, minCapacity)，否则直接返回minCapacity

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

进入ensureExplicitCapacity方法

如果elementData所需的最小长度大于目前实际的长度，则进入grow方法，进行扩容

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

进入grow方法

新数组长度=max(旧数组长度*1.5，数组所需最低长度)。如果新数组长度过大（大于Integer.MAX_VALUE - 8），进入hugeCapacity

private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

进入hugeCapacity方法

如果minCapacity溢出，抛出异常，否则返回一个合法的大的值

private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

总结

1. 空参构造创建对象，第一次添加元素时，扩容至max(10,添加元素数量)
2. 其他情况添加元素时，扩容至max(旧数组长度*1.5，最小所需容量)