源码阅读系列——基础篇（ArrayList 集合源码分析）

ArrayList是我们非常常用的一个线程不安全的List集合。ArrayList和Vector大体比较相似。我们继续阅读源码找答案。

1、类定义

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[] EMPTY_ELEMENTDATA = {}; // 无元素的默认数组，见构造函数1
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 无元素的默认数组定义，见构造函数2
    transient Object[] elementData; // 元素数组
    private int size;  // 元素数量
   
    // 构造函数1：指定大小的构造函数
    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);
        }
    }

    // 构造函数2
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
}

从上面的源码，得出以下：
ArrayList默认是一个空数组。只有制定长度时，才会生产一个定长数组。

2、扩容机制

已增加元素为例

public void add(int index, E element) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index); // 整体后移index后的所有元素
    elementData[index] = element;
    size++;
}

我看一下ensureCapacityInternal实现

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); //如果当前长度不到DEFAULT_CAPACITY（10）的长度，先设置为DEFAULT_CAPACITY
    }

    ensureExplicitCapacity(minCapacity);
}

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

    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
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;
}

由源码得出：
1、如果长度不到10，则先扩容到10。
2、如果长度大于10了，则每次扩容1.5倍。比Vector每次扩容2倍，省空间，如果不频繁扩容，效率差不多。

3、迭代器

我们常常有这样的需求，遍历数组的过程中，修改元素，但是如果像下面这样的写法，一定会有数组越界的问题：

public void removeElement(int value){
    for (int i = 0 ; i < elementList.size() ; i++){
        if(value == elementList.get(i).value){
            elementList.remove(i);
        }
    }
}

Java提供了迭代器的方式来满足以上需求，看一下迭代器的主要代码：

private class Itr implements Iterator<E> {
        protected int limit = ArrayList.this.size;

        int cursor;       // 游标，可以理解为遍历数组的指针（或者索引）。
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount; // modCount表示List被修改操作的次数。（我们在List里面的所有影响list数组的操作，都会自增1，比如List.remove()，List.clear()）

        public boolean hasNext() {
            return cursor < limit;  // 是否已经遍历到头
        }

        @SuppressWarnings("unchecked")
        public E next() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException(); // 如果发现迭代器在遍历的过程中，modCount发生变化了，则抛异常，这就是Fast-fail机制
            int i = cursor;
            if (i >= limit)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException(); // 发现数组长度越界，抛异常（理论上遍历的过程不会越界，所以理解迭代器之外有改动）
            cursor = i + 1;  // 索引后移一位，表示下一个要被遍历的元素
            return (E) elementData[lastRet = i]; // lastRet赋值为我们当前遍历的元素
        }

        public void remove() {
            if (lastRet< 0)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();

            try {
                ArrayList.this.remove(lastRet); // 移除当前遍历到的元素
                cursor = lastRet;// 下一个遍历的元素，位置index也需要-1
                lastRet = -1;
                expectedModCount = modCount; // 更新modCount
                limit--;   // 长度减1
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
    }

从上面的源码解析，我们大致可以发现迭代器的作用：他其实可以理解建立了一个封闭的空间，可以让开发者在遍历的同时修改元素，甚至影响到元素数组的大小。而由于迭代器里面实现一套对长度、遍历索引的动态变更，所以在遍历的过程中，我们不能在迭代器之外对数组有任何改动。