ArrayList源码分析

ArrayList简介

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

ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。稍后，我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。

ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。

ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

和Vector不同，ArrayList中的操作不是线程安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。

ArrayList属性

// 默认容量
private static final int DEFAULT_CAPACITY = 10;

// 一个空数组,当用户指定该 ArrayList 容量为 0 时，返回该空数组
private static final Object[] EMPTY_ELEMENTDATA = {};

/** 一个空数组实例 
* - 当用户没有指定 ArrayList 的容量时(即调用无参构造函数)，返回的是该数组==>刚创建一个 ArrayList 时，其内数据量为 0。 
* - 当用户第一次添加元素时，该数组将会扩容，变成默认容量为 10(DEFAULT_CAPACITY) 的一个数组===>通过 ensureCapacityInternal() 实现 
* 它与 EMPTY_ELEMENTDATA 的区别就是：该数组是默认返回的，而后者是在用户指定容量为 0 时返回
*/

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/** 
* ArrayList基于数组实现，用该数组保存数据, ArrayList 的容量就是该数组的长度 
* - 该值为 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，当第一次添加元素进入 ArrayList 中时，数组将扩容值 DEFAULT_CAPACITY(10) 
*/
transient Object[] elementData;

/** 
* 当前数组长度,也即ArrayList实际存储的数据数量
*/
private int size;

// 数组最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

ArrayList构造函数

　　/**
    * 在创建ArrayList时,可指定ArrayList的初始容量,也即初始数组的长度.
    * 传入参数如果是大于0，则使用用户的参数初始化，
    * 如果用户传入的参数等于0，则将空数组实例 EMPTY_ELEMENTDATA 赋值给 数组引用变量elementData
    * 如果用户传入的参数小于0，则抛出异常
    */
    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);
        }
    }

    // 空参构造函数
    public ArrayList() {
        // DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为空数组实例
        // 上文中创建了数组 Object[] elementData，在初始化一个ArrayList时，
        // 将该数组引用指向上文中已定义的空数组实例 DEFAULTCAPACITY_EMPTY_ELEMENTDATA
        // 此处，我们就可以看出，ArrayList 是基于数组实现的
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
    *  创建一个包含collection的ArrayList
    *  @param c 要放入 ArrayList 中的集合，其内元素将会全部添加到新建的 ArrayList 实例中
    *  @throws NullPointerException 当参数 c 为 null 时抛出异常
    */
    public ArrayList(Collection<? extends E> c) {
        // 将集合 c 转成 Object[] 数组
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            // 这句话意思是：c.toArray 可能不会返回 Object[]，可以查看 java 官方编号为 6260652 的 bug
            if (elementData.getClass() != Object[].class)
                 // 若 c.toArray() 返回的数组类型不是 Object[]，则利用 Arrays.copyOf(); 来构造一个大小为 size 的 Object[] 数组
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            // 替换空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

 add方法

1、add(E e)方法

add方法的执行逻辑如下：

1）确定 ArrayList 的容量大小，判断当前数组是否有足够容量存储传入的元素.

　　　　size为当前数组已使用的长度，通过调用ensureCapacityInternal(size + 1)方法来判断 ArrayList 是否需要扩容

　　　　如果当前数组已使用长度（size）加1后的大于当前的数组长度，则调用grow方法，增长数组，grow方法会将当前数组的长度变为原来容量的1.5倍。

2）确保新增的数据有地方存储之后，则将新元素添加到位于size的位置上。

3）返回添加成功布尔值。

 /**
     *增加指定的元素到ArrayList的最后位置
     * @param e 要添加的元素
     * @return
     */
    public boolean add(E e) {
        // 确定ArrayList的容量大小---严谨
        // 注意：size + 1，保证资源空间不被浪费，
        // ☆☆☆按当前情况，保证要存多少个元素，就只分配多少空间资源
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

确保添加的元素有地方存储，当第一次添加元素的时候this.size+1 的值是1，所以第一次添加的时候会将当前elementData数组的长度变为10

private static int calculateCapacity(Object[] elementData, int minCapacity) {
　　　　　// 如果数组 elementData 与 数组 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 指向同一个地址，则返回DEFAULT_CAPACITY 和 minCapacity 中值较大的那一个
　　　　　if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { 
　　　　　　　// 返回 DEFAULT_CAPACITY 和 minCapacity 中值较大的那一个 
　　　　　　　// DEFAULT_CAPACITY 默认值为10，初始时 minCapacity 值为 size+1=1 
　　　　　　　return Math.max(DEFAULT_CAPACITY, minCapacity); 
　　　　　} 
　　　　　return minCapacity; 
}

　/**
     * 私有方法：明确 ArrayList 的容量，提供给本类使用的方法
     * - 用于内部优化，保证空间资源不被浪费：尤其在 add() 方法添加时起效
     * @param minCapacity    指定的最小容量
     */
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++; // 修改次数modCount 标识自增1

        // overflow-conscious code
　　　　　// 判断是否需要扩容
　　　　　// 当前所需的数组最小长度与数组的长度对比，如果大于0，则需要扩容。
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
　　// 扩容方法
     private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
　　　　　// 数组容量扩大至原来的1.5倍 oldCapacity >> 1 即为 0.5 倍的 oldCapacity
        int newCapacity = oldCapacity + (oldCapacity >> 1);
　　　　　// 若 newCapacity 依旧小于 minCapacity
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
　　　　　// 若 newCapacity 大于最大存储容量，则进行大容量分配
        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);
    }

 /**
     * 私有方法：大容量分配，最大分配 Integer.MAX_VALUE
     * @param minCapacity
     */
private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

2、add(int index, E element)方法

这个方法其实和上面的add类似，该方法可以按照元素的位置，指定位置插入元素，具体的执行逻辑如下：
1）确保数插入的位置小于等于当前数组长度，并且不小于0，否则抛出异常
2）确保数组已使用长度（size）加1之后足够存下 下一个数据
3）修改次数（modCount）标识自增1，如果当前数组已使用长度（size）加1后的大于当前的数组长度，则调用grow方法，增长数组
4）grow方法会将当前数组的长度变为原来容量的1.5倍。
5）确保有足够的容量之后，使用System.arraycopy 将需要插入的位置（index）后面的元素统统往后移动一位。
6）将新的数据内容存放到数组的指定位置（index）上

 public void add(int index, E element) {
        rangeCheckForAdd(index); //判断角标是否越界

        ensureCapacityInternal(size + 1);  // Increments modCount!!
　　　　　//第一个是要复制的数组，第二个是从要复制的数组的第几个开始， 
　　　　　// 第三个是复制到那，四个是复制到的数组第几个开始，最后一个是复制长度
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

3、addAll

3.1 addAll(Collection<? extends E> c)

/**
     * 将一个集合的所有元素顺序添加（追加）到 lits 末尾
     * - ArrayList 是线程不安全的。
     * - 该方法没有加锁，当一个线程正在将 c 中的元素加入 list 中，但同时有另一个线程在更改 c 中的元素，可能会有问题
     * @param c  要追加的集合
     * @return <tt>true</tt> ？ list 元素个数有改变时，成功：失败
     * @throws NullPointerException 当 c 为 null 时
     */
     public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray(); // 将集合 c 转为 Object[] 数组
        int numNew = a.length; 
        ensureCapacityInternal(size + numNew);  // 扩容
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew; // list 长度
        return numNew != 0;
    }

3.2 addAll(int index, Collection<? extends E> c)

　　/**
     * 从 List 中指定位置开始插入指定集合的所有元素,
     * -list中原来位置的元素向后移
     * - 并不会覆盖掉在 index 位置原有的值
     * - 类似于 insert 操作，在 index 处插入 c.length 个元素（原来在此处的 n 个元素依次右移）
     * @param index 插入指定集合的索引
     * @param c 要添加的集合
     * @return ？ list 元素个数有改变时，成功：失败
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * @throws NullPointerException if the specified collection is null
     */
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // 扩容

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

    /**
     * 添加时检查索引是否越界
     */
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

get方法 ：用于获取 list 中指定位置上的元素

    /**
     * 返回list中指定位置上的元素
     */
    public E get(int index) {
        rangeCheck(index); // 检查是否越界

        return elementData(index);
    }

     /**
     * 检查索引 index 是否越界
     */
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
    * 返回在索引为 index 的元素：数组的随机访问
    */
     @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

set方法

    /**
    * 确保set的位置小于当前数组的长度（size）并且大于0，获取指定位置（index）元素，
    * 然后放到oldValue存放，将需要设置的元素放到指定的位置（index）上，然后将原来位
    * 置上的元素oldValue返回给用户。
    */
    public E set(int index, E element) {
        rangeCheck(index); // 检查 index 是否越界

        E oldValue = elementData(index); // 获取 list 中索引为 index 的原先所存储的元素
        elementData[index] = element; // 为 elementData[index] 重新赋值 
        return oldValue; // 返回原位置上的元素值
    }    

 contains方法

    // 判断 list 中是否包含元素o
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    /**
     * 如果 list 集合中包含元素o，则返回第一次出现元素o的位置角标，
     * 如果 list 中不包含该元素则返回 -1。
     */
    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;
    }

 remove方法

1、根据索引remove

// 删除 list 中指定位置元素
    public E remove(int index) {
        rangeCheck(index); // 判断 index 是否越界

        modCount++; // 修改次数加1
        E oldValue = elementData(index); // 获取指定位置(index)元素

        int numMoved = size - index - 1; // 计算元素移动次数
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index, numMoved); // 元素移动
        elementData[--size] = null; // size为当前 list 中所存储的元素个数, --size表示最后一个元素的角标.
        // 当数组中某个位置元素删除后,则该位置后面的元素均需向前移动一个位置,这样 --size 这个位置的元素
        // 向前移动一个位置后, elementData[--size]这个引用变量就失去了指向, 因此需要将其指向null, 然后由
        // GC 垃圾回收起进行回收.

        return oldValue;
    }

 2、根据对象remove

/**
     * 移除list中指定的第一个元素(符合条件索引最低的)
     * 如果list中不包含这个元素，则该list不会改变
     * 如果包含这个元素，index 之后的所有元素依次左移一位
     * @param o 该list中要被移除的元素
     * @return
     */
    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;
    }


    /**
     * 快速删除第 index 个元素
     * 和public E remove(int index)相比
     * 私有方法，跳过检查，不返回被删除的值
     * @param index 要删除的脚标
     */
    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
    }

3、根据角标范围remove

　　/**
     * 删除 list 中角标从 fromIndex(包括) 到 toIndex(不包括) 之间的所有元素
     */
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++; // 修改次数加一
        int numMoved = size - toIndex; // 角标 toIndex 后的所有元素左移次数
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);  // 元素左移

        // clear to let GC do its work
        int newSize = size - (toIndex-fromIndex); // 剩余元素个数
        for (int i = newSize; i < size; i++) {
            elementData[i] = null; // 将 fromIndex 到 toIndex 之间的所有元素置空,等待垃圾回收器回收
        }
        size = newSize; 
    }

4、removeAll方法

　　　/**
     * 移除list中指定集合包含的所有元素
     * @param c 要从list中移除的指定集合
     * @return {@code true} if this list changed as a result of the call
     * @throws ClassCastException 如果list中的一个元素的类和指定集合不兼容
     * (<a href="Collection.html#optional-restrictions">optional</a>)
     * @throws NullPointerException  如果list中包含一个空元素，而指定集合中不允许有空元素
     */
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c); // 判断集合 c 是否为空,为空的话抛出NullPointerException(), 不为空的话则会返回集合 c
        return batchRemove(c, false);
    }

    /**
     * 批处理移除
     * @param c 要移除的集合
     * @param complement 是否是补集
     *                   如果true：移除list中除了c集合中的所有元素
     *                   如果false：移除list中 c集合中的元素
     */
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            //遍历数组，并检查这个集合是否对应值，移动要保留的值到数组前面，w最后值为要保留的值得数量
            //根据传入的 complement 值进行处理
            //当 complement 为 true 时,即为保留：将相同元素移动到前段，
            //当 complement 为 false 时,即为不保留：将不同的元素移动到前段
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            //最后 r=size 注意for循环中最后的r++
            //     w=保留元素的大小.
            //r!=size表示可能出错了，
            if (r != size) {
                System.arraycopy(elementData, r,
                        elementData, w,
                        size - r);
                w += size - r;
            }
            //如果w==size：表示全部元素都保留了，所以也就没有删除操作发生，所以会返回false；反之，返回true，并更改数组
            //而 w!=size;即使try抛出异常，也能正常处理异常抛出前的操作，因为w始终要为保留的前半部分，数组也不会因此乱序
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

clear方法

添加操作次数（modCount），将数组内的元素都置空，等待垃圾收集器收集，不减小数组容量。

public void clear() {
        modCount++;

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

        size = 0;
    }

最后感谢：

（1）https://www.cnblogs.com/gxl1995/p/7534171344218b3784f1beb90d621337.html

（2）https://blog.csdn.net/fighterandknight/article/details/61240861

（3）https://www.cnblogs.com/skywang12345/p/3308556.html#a1