ArrayList源码分析

文章目录

1. 1. 继承体系
2. 2. 源码分析
   1. 2.1. 属性
   2. 2.2. ArrayList(int initialCapacity) 构造方法
   3. 2.3. add(E e) 方法

继承体系

源码分析

属性

/**
 * 默认容量为10，也就是通过 new ArrayList() 创建时的默认容量
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 空数组
 * 这种是通过 new ArrayList(0) 创建时用的空数组
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 空数组
 * 这种是通过 new ArrayList() 创建时用的空数组
 * 与 EMPTY_ELEMENTDATA 的区别是在添加第一个元素时使用这个空数组会初始化为 DEFAULT_CAPACITY（10）个元素
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 真正存放元素的地方
 * 使用 transient 关键字能不序列化这个字段
 */
transient Object[] elementData; // non-private to simplify nested class access

/**
 * 真正存放元素的个数
 */
private int size;

ArrayList(int initialCapacity) 构造方法

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        // 如果传入的初始容量 > 0，新建一个数组存储元素
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        // 如果传入的初始容量 = 0，使用空数组 EMPTY_ELEMENTDATA
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        // 如果传入的初始容量 < 0，抛出异常
        throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    }
}

add(E e) 方法

添加元素到末尾

public boolean add(E e) {
    // 检查是否需要扩容
    ensureCapacityInternal(size + 1);
    // 将元素插入到最后一位
    elementData[size++] = e;
    return true;
}

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

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 如果是空数组 DEFAULTCAPACITY_EMPTY_ELEMENTDATA，就初始化为默认大小 10
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    if (minCapacity - elementData.length > 0)
        // 扩容
        grow(minCapacity);
}

/**
 * 扩容
 *
 */
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    // 新容量为旧容量的 1.5 倍
    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);
}

1. 检查是否需要扩容；
2. 如果 elementData 等于 DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则初始化容量大小为 DEFAULT_CAPACITY；
3. 新容量是老容量的1.5 倍（oldCapacity + (oldCapacity >> 1)），如果加了这么多容量发现比需要的容量还小，则以需要的容量为准；
4. 创建新容量的数组并把老数组拷贝到新数组；