概述

Resizable-array implementation of the <tt>List</tt> interface.　　可变大小的数组（实现了List接口）；

　　Implements all optional list operations, and permits all elements, including null.　　实现了List的所有操作，允许所有的元素（包括null）；

The <tt>size</tt>, <tt>isEmpty</tt>, <tt>get</tt>, <tt>set</tt>, <tt>iterator</tt>, and <tt>listIterator</tt> operations run in constant time.

　　　　size、isEmpty、get、set、iterator、listIterator操作需要 O(1)时间；

The <tt>add</tt> operation runs in amortized constant time, that is, adding n elements requires O(n) time.

　　　　add操作添加n个元素，需要O(n)；

An application can increase the capacity of an<tt>ArrayList</tt> instance before adding a large number of elements using the <tt>ensureCapacity</tt> operation.

　　　　在添加大数量的元素前，会使用ensureCapacity确保ArrayList容量；

　　Note that this implementation is not synchronized.　　ArrayList的实现是非同步的；

If multiple threads access an <tt>ArrayList</tt> instance concurrently, and at least one of the threads modifies the list structurally, it must be synchronized externally.

　　　　如果多个线程并发访问ArrayList，必须在外部进行同步；

　　A structural modification is any operation that adds or deletes one or more elements, or explicitly resizes the backing array; merely setting the value of an element is not a structural modification.

　　　　结构修改：添加、删除元素、数组重置大小；（多于多线程并发需要进行同步操作）

　　If no such object exists, the list should be "wrapped" using the {@link Collections#synchronizedList Collections.synchronizedList} method.

　　　　可以使用 Collections.synchronizedList 实现同步；

The iterators returned by this class's {@link #iterator() iterator} and {@link #listIterator(int) listIterator} methods are fail-fast:

　　　　iterator、listIterator 方法是fail-fast；　　　　
　　if the list is structurally modified at any time after the iterator is created, in any way except through the iterator's own {@link ListIterator#remove() remove}

　　or {@linkListIterator#add(Object) add} methods, the iterator will throw a {@link ConcurrentModificationException}.

　　　　如果创建了iterator，调用iterator的remove、add将会抛出ConcurrentModificationException（实际用的是子类的java.util.ArrayList.Itr）

链路

add

// java.util.ArrayList.add(E)
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    
    // java.util.ArrayList.ensureCapacityInternal
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    
    // java.util.ArrayList.calculateCapacity
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    
    // java.util.ArrayList.ensureExplicitCapacity
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;                                                     // modCount递增

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)                       // 容量不足，扩容
            grow(minCapacity);
    }
    
    // java.util.ArrayList.grow
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);             // 新容量 = 旧容量 + 旧容量/2
        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);          // 将元素旧数据 copy到 新数组中
    }

同步ArrayList（Collections.synchronizedList(new ArrayList<>());)

链路

add(E e)

// java.util.Collections.synchronizedList(java.util.List<T>)
    public static <T> List<T> synchronizedList(List<T> list) {
        return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList<>(list) :          // ArrayList实现了RandomAccess
                new SynchronizedList<>(list));
    }

    // java.util.Collections.SynchronizedRandomAccessList.SynchronizedRandomAccessList(java.util.List<E>)
    SynchronizedRandomAccessList(List<E> list) {
        super(list);
    }

    // java.util.Collections.SynchronizedList.SynchronizedList(java.util.List<E>)
    SynchronizedList(List<E> list) {
        super(list);
        this.list = list;
    }
    
    // java.util.Collections.SynchronizedCollection.add             // SynchronizedRandomAccessList继承了SynchronizedList，SynchronizedList继承了SynchronizedCollection，调用的是SynchronizedCollection的add
    public boolean add(E e) {
        synchronized (mutex) {return c.add(e);}
    }