ArrayList扩容机制

ArrayList扩容机制

简介

ArrayList的底层是一个Object类型的数组，可以进行动态扩容
ArrayList不是线程安全的，不建议在多线程环境下使用
ArrayList实现了Serializable接口，因此它支持序列化，能够通过序列化传输
ArrayList实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问
ArrayList实现了Cloneable接口，能被克隆

ArrayList的属性

//默认初始化大小，第一次扩容时容量为10
private static final int DEFAULT_CAPACITY = 10;
//带参构造初始为0时返回这个空数组
private static final Object[] EMPTY_ELEMENTDATA = {}; 
//无参构造器返回这个空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//用来存放ArrayList的元素
transient Object[] elementData;
//数组长度
private int size;

ArrayList的初始化方法

public ArrayList() {
    //无参构造，默认赋值成一个空数组
    this.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);
    }
}

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)
            //toArray()方法返回Object类型数组
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

ArrayList的扩容

添加操作

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
	
//minCapacity是添加元素后的数组长度
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}	

//如果是空数组，就返回10和size+1中的最大值，因此第一次添加元素时，那么容量就为10
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    //快速报错机制中使用
    modCount++;

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

ArrayList扩容的核心方法

//minCapacity可能是10，或者size+1
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //扩容1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
    	//返回Integer.MAX_VALUE
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    //使用Arrays.copyOf方法拷贝
    elementData = Arrays.copyOf(elementData, newCapacity);
}

当扩容后的容量长度大于数组的最大容量时进入此方法

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

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

Arrays的方法，用于赋值数组

public static <T> T[] copyOf(T[] original, int newLength) {
    return (T[]) copyOf(original, newLength, original.getClass());
}	

总结

使用无参构造创建时ArrayList，默认赋值成一个空数组，进行第一次添加数据时分配10个对象空间，当添加第11个数据时扩容1.5倍为10+5=15，当添加第16个数据时扩容为15+7.5=22，之后以此类推，每次扩容都是通过Arrays.copyOf(elementData, newCapacity) 这样的方式实现的。