源码：List之ArrayList（一）

简介

ArrayList：

1. 容量可以改变的非线程安全集合
2. 基于动态数组实现
3. 支持快速随机访问(因为继承RandomAccess接口)
4. 动态扩容

缺点：

1. 插入与删除速度慢。

源码解读

1. 实现了 RandomAccess 接口，因此支持随机访问。这是理所当然的，因为 ArrayList 是基于数组实现的。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

2. 数组的默认大小为 10

private static final int DEFAULT_CAPACITY = 10;

3. 构造方法

//默认的初始化
private static final Object[] EMPTY_ELEMENTDATA = {};

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        //值大于0时，根据参数值创建
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                initialCapacity);
    }
}

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

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

4. 扩容

public boolean add(E e) {
    //能否容纳size+1的元素
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    //判断是否是空构造创建的
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // 最低要求容量大于存放数组长度
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

//进行扩容
private void grow(int minCapacity) {
    //防止扩容1.5倍后超出int表示范围
    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);
}

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; //Integer.MAX_VALUE整形最大值

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

若使用无参构造时，放置1000个元素，ArrayList需要扩容13次，但使用有参构造，直接分配1000个存储空间。

5.调用 add(index,e) 在指定位置添加的话：

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

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length) src表示源数组，srcPos表示源数组要复制的起始位置，desc表示目标数组，length表示要复制的长度

序列化

由于 ArrayList 是基于动态数组实现的，所以并不是所有的空间都被使用。因此使用了 transient 修饰，可以防止被自动序列化。

transient Object[] elementData;