JDK学习笔记之ArrayList

ArrayList是一个常用的类，实现了List接口，拥有随机访问的特性。

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

其属性包括：

private static final int DEFAULT_CAPACITY = 10;

默认容量，用private static final修饰，是不可变的共享变量。

private static final Object[] EMPTY_ELEMENTDATA = {};

共享的空数组实例，ArrayList只有一个空数组，所有的空数组都指向这个实例。

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

共享空数组实例，不同的是当添加了第一个元素，使得数组扩容时，扩容到默认容量。

transient Object[] elementData;

transient修饰的Object数组。transient修饰的变量不参与序列化。

private int size;

元素个数。

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

构造函数，可以设置初始容量。
如果初始容量大于0，new一个Object数组。
如果初始容量等于0，把数组设置为静态数组EMPTY_ELEMENTDATA。
小于0抛出异常。

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

无参构造函数，把数组设置为DEFAULTCAPACITY_EMPTY_ELEMENTDATA。该数组扩容后容量是10。

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

输入参数为Collection的构造函数，同样size为0时数组设置为EMPTY_ELEMENTDATA。

public int size() {
    return size;
}

返回元素个数

public boolean isEmpty() {
    return size == 0;
}

判断是否为空

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

判断某个Object在数组中的位置。ArrayList可以包含重复元素，所以返回的是第一次出现的下标。

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

也可以返回最后一次出现的下标。

public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

返回一个对应的数组，类型是Object。

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

返回一个指定类型的数组。

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

    return elementData(index);
}

随机访问列表元素。
其中：

private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

检查是否越界

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

返回特定位置上的元素，强转为E类型。

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

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

修改某个位置上的元素。

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

添加一个元素。

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

移除所有和传入元素相同的元素，调用fastRemove方法移除。

private void fastRemove(int index) {
    modCount++;
    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
}

和按照下标移除类似。

public void clear() {
    modCount++;

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

    size = 0;
}

清除所有元素，把数组所有下标元素置为空，并把size修改为0.

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

把集合中所有元素添加到ArrayList中。
首先把集合转换成一个Object数组，修改elementData的长度，把Object数组的内容复制到elementData中，修改size。
如果集合不为空返回true。

ArrayList数组长度相关的函数包括以下几个：

public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        // any size if not default element table
        ? 0
        // larger than default for default empty table. It's already
        // supposed to be at default size.
        : DEFAULT_CAPACITY;

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

可被外界调用的函数，作用是如果传入的扩展容量参数比默认的扩展容量还要大的话，调用相应的扩展容量函数。如果不比默认量大则不扩展，因为需要的话会自动扩展到这个默认容量。

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

供内部调用的函数，调用另一个函数扩展容量。
扩展的大小是默认量和传入参数中的最大值。
之前提到过，如果是DEFAULTCAPACITY_EMPTY_ELEMENTDATA空数组，会有一个默认扩展容量10。

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

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

如果需要扩展（传入参数大于数组长度），调用grow函数扩展容量。

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

容量扩展为原来的1.5倍。
如果还是比传入参数小，扩展为传入参数。
如果新容量大于最大容量，调用hugeCapacity函数。然后把数组复制一份，扩展为新数组。

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