ArrayList底层源码分析、扩容机制

扩容机制

1、new ArrayList()无参构造，初始化大小为0，在第一次插入时，初始化大小为10，每次扩容为上次的1.5倍
2、 new ArrayList(3)有参构造，初始化大小为指定个数(3)，每次扩容为上次的1.5倍
3、1.5倍为取整，舍弃小数

参数说明

// 初始化集合大小
private static final int DEFAULT_CAPACITY = 10;
// 
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 存放元素  transient表示瞬间、短暂，表示不会被序列化
// 第一次添加元素或者扩容后,无值的用null填充，假设集合容量为10，无值的位置用null填充，最后elementData的长度为10
transient Object[] elementData; // non-private to simplify nested class access

private int size;

初始化

List<Object> list1 = new ArrayList<>();	// 无参
List<Object> list2 = new ArrayList<>(8); // 指定list大小
List<Object> list3 = new ArrayList<>(list1); // list

源码分析

初始化源码

// 无参构造时 elementData 初始化为{} 空集合,在第一次添加元素时才会扩容数组容量为10
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 指定数组大小
public ArrayList(int initialCapacity) {
   if (initialCapacity > 0) {
	   // 直接初始化 例如initialCapacity为3 则elementData={null,null,null}
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

add方法

public boolean add(E e) {
	// 先确认是否需要扩容
   ensureCapacityInternal(size + 1);  // Increments modCount!!
   // 存放元素 后++ 运行后再执行++操作
    elementData[size++] = e;
    return true;
}
// 指定下标存放
public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

// ensureCapacityInternal方法  minCapacity参数为插入前集合内元素个数+1
 private void ensureCapacityInternal(int minCapacity) {
   ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 返回集合最小容量  elementData为{}时返回10  否则则为新插入数据的下标
private static int calculateCapacity(Object[] elementData, int minCapacity) {
	// elementData为{} 空数组
    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);
}

grow 扩容方法

// 第一次add时minCapacity=10
private void grow(int minCapacity) {
   // 老集合容量  第一次添加为0
    int oldCapacity = elementData.length;
    // 新容量 = 老容量 + 老容量/2(小数时取整,舍弃小数)  第一次添加新容量为0
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
	    // 新容量 < 集合最小容量 则新容量大小=集合最小容量
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
    	// 新容量 > 最大容量
        newCapacity = hugeCapacity(minCapacity);
        
    // 将elementData集合大小扩容到newCapacity
    // 第一次add时 最后生成{null,null,null...} 10个null
    // 假设有值 {1,2,...,10} 扩容1.5倍后会变成 {1,2,...,10,null,null,null,null,null} 无值用null填充
    elementData = Arrays.copyOf(elementData, newCapacity);
}