ArrayList 源码分析

1）ArrayList 特点

• List 接口的可变数组实现，ArrayList 允许使用任何元素，包括 null。

• ArrayList 和 Vector 基本类似，只不过 Vector 是线程安全的，ArrayList 是线程不安全的。

• size、isEmpty、get、set、iterator 和 listIterator 以常量时间运行，其他的操作基本以线性时间运行。

• 每个 ArrayList 都有一个容量，容量表示该 ArrayList 当前能容纳的元素个数，随着元素的增加，ArrayList 会自动扩容。

• 在创建 ArrayList 时可以指定一个合适的初始化容量，以减少频繁扩容带来的性能损耗。

• ArrayList 是线程不安全的，多线程并发访问 ArrayList 并且至少有一个线程修改了它的结构【增加、删除元素、扩容等】，
  则 ArrayList 将抛出 ConcurrentModificationException 异常。

• 快速失败机制：iterator 和 listIterator 返回的迭代器是快速失败的，如果不是通过 ListIterator#remove() 或 ListIterator#add(Object) 方法修改其结构，
  则 ArrayList 将尽最大努力抛出 ConcurrentModificationException 异常。

• ArrayList 的缩容机制：通过 trimToSize 方法将 ArrayList 的容量缩小为当前元素的个数，以减少 ArrayList 的内存占用。

• ArrayList 的扩容机制：默认为 1.5 倍向下取整扩容，如果批量添加元素，则以 size+newNum 进行扩容。

2）创建实例

    /**
     * ArrayList 底层存储元素的数组缓冲区
     */
    transient Object[] elementData;    // 用于在空实例之间共享的空对象数组，用于简化扩容实现
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};    
    // 创建容量为 10 的空 ArrayList 实例
    public ArrayList() {        this.elementData = ArrayList.DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }    /**
     * 基于用户指定的容量创建空 ArrayList 实例
     */
    public ArrayList(int initialCapacity) {        if (initialCapacity > 0) {            // 创建指定大小的对象数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {            // 使用共享的空数组
            this.elementData = ArrayList.EMPTY_ELEMENTDATA;
        } else {            throw new IllegalArgumentException("Illegal Capacity: "+
                    initialCapacity);
        }
    }    /**
     * 基于指定的集合创建 ArrayList 实例
     */
    public ArrayList(Collection<? extends E> c) {        // 集合转化为对象数组
        this.elementData = c.toArray();        /**
         * 集合容量不为 0，并且类型不是 Object[].class，则将其转换为对象数组。
         */
        if ((this.size = this.elementData.length) != 0) {            if (this.elementData.getClass() != Object[].class) {                this.elementData = Arrays.copyOf(this.elementData, this.size, Object[].class);
            }
        } else {            // 空集合默认使用共享空数组
            this.elementData = ArrayList.EMPTY_ELEMENTDATA;
        }
    }

3）在尾部添加元素

    /**
     *  【modCount 属性定义在 AbstractList 中】
     *  【ArrayList 被结构化修改的次数，结构化修改主要是改变 List 大小的操作】
     *  【该属性主要被 {@code iterator} and {@code listIterator} 方法返回的迭代器使用，
     *  用于在迭代器遍历元素时阻止并发修改带来的数据错误，如果此字段的值发生意外的更改，
     *  则迭代器将抛出 ConcurrentModificationException 异常。
     *  它实现了在列表出现并发修改时的快速失败机制。】
     */
    protected transient int modCount = 0;    /**
     * 在 ArrayList 尾部新增元素
     */
    @Override
    public boolean add(E e) {
        modCount++;        this.add(e, this.elementData, this.size);        return true;
    }    /**
     * 将方法字节码控制在 35(the -XX:MaxInlineSize default value) 个之内，以实现预编译和内联。
     */
    private void add(E e, Object[] elementData, int s) {        // 如果当前元素个数和底层数组长度一致，则需要执行扩容
        if (s == elementData.length) {
            elementData = this.grow();
        }        // 插入元素
        elementData[s] = e;        // 增加元素个数
        this.size = s + 1;
    }    /**
     * 默认每次增加一个空间，触发 1.5 倍向下取整扩容
     */
    private Object[] grow() {        return this.grow(this.size + 1);
    }    /**
     * 增加 ArrayList 的容量以满足最少能容纳 minCapacity 个元素
     */
    private Object[] grow(int minCapacity) {        // 基于数组拷贝实现扩容
        return this.elementData = Arrays.copyOf(this.elementData,                this.newCapacity(minCapacity));
    }    /**
     * 可分配的最大数组大小
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;    /**
     * 基于预期容量计算新的容量
     */
    private int newCapacity(int minCapacity) {        // overflow-conscious code
        final int oldCapacity = this.elementData.length;        /**
         * 1.5 倍向下取整扩容
         */
        final int newCapacity = oldCapacity + (oldCapacity >> 1);        /**
         * 默认扩容后的容量小于预期容量，则以预期容量为准
         */
        if (newCapacity - minCapacity <= 0) {            // 第一次扩容时，取 10 和 minCapacity 的最大值
            if (this.elementData == ArrayList.DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {                return Math.max(ArrayList.DEFAULT_CAPACITY, minCapacity);
            }            // 预期容量溢出
            if (minCapacity < 0) {                throw new OutOfMemoryError();
            }            return minCapacity;
        }        /**
         * 新的容量小于等于 Integer.MAX_VALUE - 8 则直接返回，
         * 否则基于预期容量返回 Integer.MAX_VALUE - 8 或 Integer.MAX_VALUE
         */
        return newCapacity - ArrayList.MAX_ARRAY_SIZE <= 0
                ? newCapacity
                        : ArrayList.hugeCapacity(minCapacity);
    }    private static int hugeCapacity(int minCapacity) {        // 预期容量已经溢出，则抛出 OutOfMemoryError
        if (minCapacity < 0) {            throw new OutOfMemoryError();
        }        return minCapacity > ArrayList.MAX_ARRAY_SIZE
                ? Integer.MAX_VALUE
                        : ArrayList.MAX_ARRAY_SIZE;
    }

4）在指定索引处添加元素

    /**
     * 在指定的位置插入元素
     */
    @Override
    public void add(int index, E element) {        this.rangeCheckForAdd(index);
        modCount++;        final int s;
        Object[] elementData;        // 当前元素个数等于底层数组容量，则执行扩容
        if ((s = this.size) == (elementData = this.elementData).length) {
            elementData = this.grow();
        }        // 将目标索引处的元素集体右移一个位置
        System.arraycopy(elementData, index,
                elementData, index + 1,
                s - index);        // 将新元素更新到目标索引处
        elementData[index] = element;        // 递增元素个数值
        this.size = s + 1;
    }    private void rangeCheckForAdd(int index) {        if (index > this.size || index < 0) {            throw new IndexOutOfBoundsException(this.outOfBoundsMsg(index));
        }
    }

5）将集合中的元素顺序加入到 ArrayList 尾部

    /**
     * 将集合中的元素顺序加入到 ArrayList 尾部
     */
    @Override
    public boolean addAll(Collection<? extends E> c) {        final Object[] a = c.toArray();
        modCount++;        // 获取需要添加的元素总个数
        final int numNew = a.length;        // 集合为空则直接返回
        if (numNew == 0) {            return false;
        }
        Object[] elementData;        final int s;        // 新增元素个数大于 ArrayList 的剩余容量，则执行扩容，预期容量为 size+newNum
        if (numNew > (elementData = this.elementData).length - (s = this.size)) {
            elementData = this.grow(s + numNew);
        }        // 将集合中的元素拷贝到 elementData 数组中
        System.arraycopy(a, 0, elementData, s, numNew);        // 增加总元素个数
        this.size = s + numNew;        return true;
    }

6）获取指定索引处的元素

    /**
     * 获取指定索引处的元素
     */
    @Override
    public E get(int index) {        // 下标校验
        Objects.checkIndex(index, this.size);        return this.elementData(index);
    }    // 位置访问操作
    /**
     * 获取指定索引处的元素
     * created by ZXD at 15 Jul 2018 T 11:28:00
     * @param index
     * @return
     */
    E elementData(int index) {        return (E) this.elementData[index];
    }

7）替换指定索引处的元素，并返回旧值

    /**
     * 替换指定索引处的元素，并返回旧值
     */
    @Override
    public E set(int index, E element) {        // 下标校验
        Objects.checkIndex(index, this.size);        // 读取旧值
        final E oldValue = this.elementData(index);        // 更新新值
        this.elementData[index] = element;        // 返回旧值
        return oldValue;
    }

8）移除指定索引处的元素

    /**
     * 移除指定索引处的元素
     */
    @Override
    public E remove(int index) {        // 下标校验
        Objects.checkIndex(index, this.size);        final Object[] es = this.elementData;        @SuppressWarnings("unchecked")        final E oldValue = (E) es[index];        this.fastRemove(es, index);        return oldValue;
    }    /**
     * 移除元素时，跳过索引校验并且不返回旧元素的值
     */
    private void fastRemove(Object[] es, int i) {
        modCount++;        final int newSize;        // 计算新的 size 值，如果 size 值大于目标索引
        if ((newSize = this.size - 1) > i) {            // 如果移除索引在数组中间，则目标索引处右侧的元素集体左移一个单位
            System.arraycopy(es, i + 1, es, i, newSize - i);
        }        // 将最后一个元素置为 null
        es[this.size = newSize] = null;
    }

9）移除指定的目标元素

    /**
     * 通过 {@link Object#equals(Object)} 方法获取第一个匹配的元素并移除
     */
    @Override
    public boolean remove(Object o) {        final Object[] es = this.elementData;        final int size = this.size;        int i = 0;        // 首先获取目标元素的索引
        found: {            if (o == null) {                for (; i < size; i++) {                    if (es[i] == null) {                        break found;
                    }
                }
            } else {                for (; i < size; i++) {                    if (o.equals(es[i])) {                        break found;
                    }
                }
            }            return false;
        }        // 快速移除目标元素
        this.fastRemove(es, i);        return true;
    }

10）移除指定索引间的元素

    /**
     * 移除指定索引范围内的所有元素，包括开始索引，不包括结束索引
     */
    @Override
    protected void removeRange(int fromIndex, int toIndex) {        if (fromIndex > toIndex) {            throw new IndexOutOfBoundsException(
                    ArrayList.outOfBoundsMsg(fromIndex, toIndex));
        }
        modCount++;        this.shiftTailOverGap(this.elementData, fromIndex, toIndex);
    }    /** Erases the gap from lo to hi, by sliding down following elements. */
    private void shiftTailOverGap(Object[] es, int lo, int hi) {
        System.arraycopy(es, hi, es, lo, this.size - hi);        for (int to = this.size, i = this.size -= hi - lo; i < to; i++) {
            es[i] = null;
        }
    }

11）移除 ArrayList 中包含在目标集合中的所有元素

    /**
     * 移除 ArrayList 中包含在目标集合中的所有元素，通过 {@link Object#equals(Object)} 进行相等性判断
     */
    @Override
    public boolean removeAll(Collection<?> c) {        return this.batchRemove(c, false, 0, this.size);
    }    /**
     * created by ZXD at 30 Aug 2018 T 22:16:52
     * @param c 目标集合
     * @param complement    ArrayList 中的元素需要移除还是保留，false 表示移除，true 表示保留
     * @param from  开始索引
     * @param end   结束索引
     * @return
     */
    boolean batchRemove(Collection<?> c, boolean complement,            final int from, final int end) {
        Objects.requireNonNull(c);        // 暂存底层数组
        final Object[] es = this.elementData;        int r;        // Optimize for initial run of survivors
        for (r = from;; r++) {            // 如果已经全部遍历完，没有需要处理的元素，则直接返回
            if (r == end) {                return false;
            }            // 找到第一个需要丢弃的元素下标
            if (c.contains(es[r]) != complement) {                break;
            }
        }        // 暂存需要处理元素的下一个位置
        int w = r++;        try {            // 遍历余下的所有元素
            for (Object e; r < end; r++) {                // 保留满足条件的目标元素
                if (c.contains(e = es[r]) == complement) {
                    es[w++] = e;
                }
            }
        } catch (final Throwable ex) {            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            System.arraycopy(es, r, es, w, end - r);
            w += end - r;            throw ex;
        } finally {            // 修改并发计数值
            modCount += end - w;            this.shiftTailOverGap(es, w, end);
        }        return true;
    }

12）只保留 ArrayList 中包含在目标集合中的所有元素

    /**
     * 保留 ArrayList 中包含在目标集合中的所有元素，通过 {@link Object#equals(Object)} 进行相等性判断
     */
    @Override
    public boolean retainAll(Collection<?> c) {        return this.batchRemove(c, true, 0, this.size);
    }