Java核心源码阅读之容器--ArrayList

ArrayList是java核心容器List下的一个子类，底层使用数组实现，可以包含重复元素，允许null元素存在，可以通过指定下标快速获得元素值。下面分为三块内容：成员变量、构造方法、核心方法。

成员变量

elementData

ArrayList包含的元素存储在该数组中，该数组的长度代表了ArrayList的容量（注意和size不同，size代表的是ArrayList中存储的元素个数）。可以看到，ArrayList的底层是用数组实现的。
若ArrayList当前实例为空（size为0），且elementData与DEFAULTCAPACITY_EMPTY_ELEMENTDATA相等时，在该列表中加入到一个元素就将其扩展为默认容量（DEFAULT_CAPACITY）的大小。

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 * will be expanded to DEFAULT_CAPACITY when the first element is added.
 */
transient Object[] elementData; // non-private to simplify nested class access

size

//数组的大小（数组中元素的数量）
private int size;

DEFAULT_CAPACITY

//默认的初始化容量为10。
private static final int DEFAULT_CAPACITY = 10;

EMPTY_ELEMENTDATA

 //一个空的实例数组
private static final Object[] EMPTY_ELEMENTDATA = {};

DEFAULTCAPACITY_EMPTY_ELEMENTDATA

这个成员变量看起来和EMPTY_ELEMENTDATA没有任何区别，但其实我们在看构造方法时就可以发现，这个变量和EMPTY_ELEMENTDATA是用来区分同样都是空数组时，List<> list = new ArrayList<>()和List<> list = new ArrayList<>(0)等不同的构造方法在加入第一个元素时膨胀elementData数组的区别。

/**
 * Shared empty array instance used for default sized empty instances. We
 * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
 * first element is added.
 */
 //一个空的实例数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

构造方法

ArrayList共有三个构造方法，分别是无参数（默认大小为0）、一个int型参数（指定容量大小）以及一个Collection参数（将其他容器中的内容复制到ArrayList中）。

ArrayList(int initialCapacity)

创建一个指定大小的List，若指定大小为0，则使elementData等于EMPTY_ELEMENTDATA。

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

ArrayList()

创建一个空的List，此时elementData等于DEFAULTCAPACITY_EMPTY_ELEMENTDATA。

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

ArrayList(Collection<? extends E> c)

创建一个List，List中的元素为集合c中的元素。

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

核心方法

ArrayList最常用的方法包括获取某个元素的index、插入一个元素、删除一个元素、获取index位置的元素、清空数组等。

indexof（时间复杂度O(n)）

时间复杂度为O(n)。遍历数组元素，找到元素的下标位置，若未出现，则返回-1。indexOf方法是从前往后遍历，lastIndexOf是从后往前遍历。从代码中可以看出，ArrayList中允许元素为null。

//获取指定元素第一次出现的index
public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}
//获取指定元素最后一次出现的index
public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

clone

获得一个当前数组的浅拷贝。拷贝了一个新的数组，但数组中元素本身并没有被拷贝。

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

get（时间复杂度O(1)）

获取指定下标的元素。时间复杂度O(1)。
首先判断index的值是否合法，不合法直接抛出异常，合法返回elementData中的对应下标的元素。

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

    return elementData(index);
}
E elementData(int index) {
    return (E) elementData[index];
}

set（时间复杂度O(1)）

替换指定index的元素值。时间复杂度O(1)。返回index原本的值。

public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

add（可能需要扩容，时间复杂度O(1)/O(n)）

在指定index或者数组尾部插入元素。
在尾部插入首先保证数组容量够大（size+1），接着在最后位置插入一个元素。时间复杂度O(1)。
在指定index插入元素也需要保证数组容量够大，再将原数组index后的元素都向后移一位，再将index位置的元素改为参数中的元素值。时间复杂度为O(n)。

//数组尾部插入元素
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
//数组index位置处插入元素
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++;
}

因为插入元素可能会有数组容量不够大的情况，涉及到数组的扩容操作。
扩容操作就是把数组容量增加原来容量的一半。代码下面贴出来了。

//确保数组的容量大于等于minCapacity
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//如果数组初始化方式为list = new ArrayList()，在插入第一个元素时，将数组容量设为默认大小--10。
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    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);
}
//终于来到扩容的函数了
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //新的容量在原来容量的基础上增加了一半
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //如果新的容量还是不够大，则将容量改为minCapacity
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    //如果新的容量比最大容量更大，将容量扩展为Integer.MAX_VALUE。
    //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    //扩展数组容量为newCapacity
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

remove（时间复杂度O(n)）

删除指定index的元素或是删除某个指定的元素。
删除指定index的元素就是将指定index后的元素都往前移一位，并把数组最后一位的元素置为null（垃圾回收器会自动回收该块内存），size减1，并返回被删除的那个元素。时间复杂度为O(n)。
删除指定元素就是在数组中遍历，找到第一个该元素，删除并返回true，否则返回false。这里调用的fastRemove(index)函数与remove(index)类似，省去了边界检查等操作。时间复杂度为O(n)。

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;
}
public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

总结

ArrayList底层使用数组实现，根据下标获取元素很快，但要在指定位置插入或者删除操作需要移动后面所有元素，较慢。且ArrayList是线程不安全的，当有多个线程同时修改时，会出现问题，可考虑用Vector代替（Vector在方法中使用了synchronized关键字修饰）。