ArrayList源码解析（上）

成员变量

1. elementData为实际存储数据的数组
2. size为ArrayList的实际大小，和elementData的长度有所区别
3. 有一个特殊的地方，elementData使用transient修饰，即不可以被序列化，这么做的原因是：
   elementData数组的长度在大多数情况下，是大于实际数据的数量size的，所以不需要将空的元素也进行序列化操作。对elementData的序列化操作其实是由writeObject()和readObject()实现的。

private static final long serialVersionUID = 8683452581122892189L;

//默认的容量
private static final int DEFAULT_CAPACITY = 10;

private static final Object[] EMPTY_ELEMENTDATA = {};

//实际存储数据的其实是这个数组
private transient Object[] elementData;

//ArrayList的大小，和elementData的长度不一定相等
private int size;

构造函数

1. 三个构造函数
2. 最后一个函数由于c.toArray可能不会反回一个Object数组，所以特殊处理一下

public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                initialCapacity);
    this.elementData = new Object[initialCapacity];
}

public ArrayList() {
    super();
    this.elementData = EMPTY_ELEMENTDATA;
}

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

关于扩展容量的相关操作

1. 方法调用关系：ensureCapacity() -> ensureExplicitCapacity() -> grow() -> hugeCapacity()
2. 核心的方法是grow()方法，如果minCapacity大于原来容量的1.5倍，容量增加到minCapacity；否则增加到1.5倍。
3. 对于ensureCapacity()这个方法，如果事先知道ArrayList所需存储的数据量大小，我们可以直接调用来设置，避免每次拷贝数组花费的额外时间，提升效率。

/**
 * 按照size的大小缩减elementData的长度
*/
public void trimToSize() {
    //操作计数器，定义在AbstractList中
    modCount++;
    if (size < elementData.length) {
        elementData = Arrays.copyOf(elementData, size);
    }
}

/**
 * 增加容量到minCapacity大小
 */
public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != EMPTY_ELEMENTDATA)
        // any size if real element table
        ? 0
        // larger than default for empty table. It's already supposed to be
        // at default size.
        : DEFAULT_CAPACITY;

    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}

/**
* 主要为add方法所用
*/
private void ensureCapacityInternal(int minCapacity) {
    if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

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

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

/**
 * The maximum size of array to allocate.
 * Some VMs reserve some header words in an array.
 * Attempts to allocate larger arrays may result in
 * OutOfMemoryError: Requested array size exceeds VM limit
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
 * 增加容量的核心函数。
 * 如果minCapacity大于原来容量的1.5倍，容量增加到minCapacity；否则增加到1.5倍。
 */
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

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