ArrayList之扩容与迭代器

1. 扩容

ArrayList扩容包括ensureCapacity（对外开放）和ensureCapacityInternal（内部隐式调用）两个接口：

1' 两者都调用ensureExplicitCapacity接口进行扩容

2' ensureExplicitCapacity在当前容量 < 指定的最小容量时，进行扩容

3' 扩容策略：新容量 = 旧容量 * 1.5

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 Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 默认容量空数组：默认初始容量
    private static final Object[] EMPTY_ELEMENTDATA = {}; // 空数组：指定容量为0
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; // 最大数组大小

    transient Object[] elementData;
    private int size;

    public ArrayList() { // 未指定初始容量
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; // 分配默认容量空数组
    }

    public ArrayList(int initialCapacity) { // 指定初始容量
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity]; // 为elementData分配空间
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA; // 分配空数组
        } else {
            throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
        }
    }

    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class); // 拷贝elementData
        } else {
            this.elementData = EMPTY_ELEMENTDATA; // 分配空数组
        }
    }

    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0 : DEFAULT_CAPACITY;
        if (minCapacity > minExpand) { // 若elementData为默认容量空数组，则指定最小容量必须大于默认容量（10）才真正进一步扩容
            ensureExplicitCapacity(minCapacity);
        }
    }

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

    private void ensureCapacityInternal(int minCapacity) {
        // elementData为默认容量空数组，则在指定的最小容量和默认容量（10）中选择较大大者进行扩容
        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) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量 = 旧容量 * 1.5
        if (newCapacity - minCapacity < 0) // 若刚计算出的新容量 < 指定的最小容量，则新容量 = 指定的最小容量
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0) // 新的容量 > 最大数组大小，则新容量 = 最大整数
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

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

    ... ...
}

public class Arrays {
    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        T[] copy = ((Object)newType == (Object)Object[].class) ? (T[]) new Object[newLength] // Object[]类型
            : (T[]) Array.newInstance(newType.getComponentType(), newLength); // 其它数组类型
        System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
        return copy;
    }

    ... ...
}

2. 迭代器

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    ... ...
    public Iterator<E> iterator() {
        return new Itr();
    }

    public ListIterator<E> listIterator() {
        return new ListItr(0);
    }

    public ListIterator<E> listIterator(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }

    ... ...
}

1）ArrayList.Itr

private class Itr implements Iterator<E> {
    int cursor;       // 下次返回元素的位置
    int lastRet = -1; // 当前返回元素的位置
    int expectedModCount = modCount; // ArrayList.this.modCount

// 判断在迭代过程中是否调用过ArrayList方法修改过elementData
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }

    public boolean hasNext() {
        return cursor != size;
    }

    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1; // cursor++
        return (E) elementData[lastRet = i]; // lastRet纪录当前返回元素的位置，cursor = lastRet + 1
    }

    public void remove() {
        if (lastRet < 0) // 未调用过Itr.next || 未调用ListItr.previous || 已调用过Itr.remove || 已调用过ListItr.add
            throw new IllegalStateException();
        checkForComodification();
        try {
            ArrayList.this.remove(lastRet); // 删除lastRet处的元素
            cursor = lastRet; // 不影响下次previous或next的调用
            lastRet = -1;
            expectedModCount = modCount; // ArrayList.remove方法将使modCount++
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    ... ...
}

2）ArrayList.ListItr

private class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {
        super();
        cursor = index;
    }

    public boolean hasPrevious() {
        return cursor != 0;
    }

    public int nextIndex() { // 下次调用next方法返回元素的位置
        return cursor;
    }

    public int previousIndex() { // 下次调用previous方法返回元素的位置
        return cursor - 1;
    }

    public E previous() {
        checkForComodification();
        int i = cursor - 1;
        if (i < 0)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i;
        return (E) elementData[lastRet = i]; // lastRet纪录当前返回元素的位置，cursor = lastRet
    }

    public void set(E e) {
        if (lastRet < 0)  // 未调用Itr.next || 未调用ListItr.previous || 已调用Itr.remove || 已调用ListItr.add
            throw new IllegalStateException();
        checkForComodification();
        try {
            ArrayList.this.set(lastRet, e); // 设置lastRet处的元素
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    public void add(E e) {
        checkForComodification();
        try {
            int i = cursor;
            ArrayList.this.add(i, e); // 在cursor处添加新元素等价于：
            // 1. 在用previous方法返回元素时：在lastRet前置位插入元素
            // 2. 在用next方法返回元素时：在lastRet后置位插入元素
            cursor = i + 1; // 下次调用previous方法则返回刚插入的元素，不影响下次next方法的调用
            lastRet = -1;
            expectedModCount = modCount; // ArrayList.add方法将使modCount++
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
}