ArrayList

一、概述

ArrayList是基于数组实现的List，是可以动态增长和缩减的索引序列

优点：可以顺序存储，随机存取，数据元素与位置相关联，因此查找效率高，索引遍历快，尾部插入与删除的速度与LinkedList的速相差无几

缺点：线程不安全，插入与删除慢，需要通过移动元素来实现，因此效率低

实现了RandomAccess，所以在遍历它的时候推荐使用for循环

二、源码

1、属性和构造方法

//元素数组
transient Object[] elementData;

elementData就是ArrayList内部维护的数组，被transient修饰的原因是因为ArrayList的序列化和反序列化是直接用writeObject和readObject读写size和element的，elementData是一个缓存数组，有些空间没有储存实际元素，采用writeObject和readObject来操作可以保证只序列化实际存储的那些元素，而不是整个数组，从而节省空间和时间

//空对象数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//缺省空对象数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

2个都是final的空数组，ArrayList有3个构造函数，DEFAULTCAPACITY_EMPTY_ELEMENTDATA用于在无参构造时赋值给elementData，而参数为0和空集合的构造函数时赋值的是EMPTY_ELEMENTDATA

在1.8中DEFAULTCAPACITY_EMPTY_ELEMENTDATA代替了1.7中的EMPTY_ELEMENTDATA，1.8的EMPTY_ELEMENTDATA代替了1.7的new Object[initialCapacity]，在1.7中如果容量是0的话会创建一个空数组赋值给elementData，1.8在一定程度上减少了空数组的存在，降低内存的消耗

//缺省容量
private static final int DEFAULT_CAPACITY = 10;
//实际元素大小，默认为0
private int size;
// 最大数组容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

其他属性

public ArrayList(int initialCapacity)
public ArrayList()
public ArrayList(Collection<? extends E> c)

3个构造方法

2、add(E e)方法、扩容

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

ensureCapacityInternal扩容

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

calculateCapacity先确定要扩容的值，ensureExplicitCapacity

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

如果是空数组的话就取默认10和长度参数的最大值（第一次扩容最小10）

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

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

modCount是AbstractList里的属性，用来记录数组的修改次数，如果在迭代器的使用过程中其他线程修改了数组，迭代器会抛出异常，HashMap也是类似，所以遍历那些非线程安全的数据结构时，尽量使用迭代器

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

ArrayList真正扩展数组的地方，通过位运算原长度加上原长度/2，扩容至1.5倍，最终通过Arrays.copyOf里创建新的扩容后数组对象，然后使用System.arraycopy复制数组，浅复制

3、add(int index, E element)方法

public void add(int index, E element) {
    //校验index是否越界
    rangeCheckForAdd(index);
    //扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //将index之后的元素都往后移一位
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    //在目标位置上存放元素
    elementData[index] = element;
    size++;
}

增加了一次复制，将index之后的元素都往后移一位

4、remove(int index)方法

public E remove(int index) {
    //校验是否越界
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0)
        //移动元素
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

5、clear()方法

public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

将数组中的元素都至为null，等待垃圾回收

6、get(int index)方法

public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}