java核心知识之集合详解七（ArrayList底层源码解析）

ArrayList底层类继承实现图

首先来看一下ArrayList实现类的底层继承图。

Iterable接口： Iterable从英语翻译的角度来说是可迭代的。可以知道实现了这个接口的集合类是可以支持迭代的。

Iterator接口： Iterator从英语翻译的角度来说是迭代器。它就是提供迭代机制的对象，具体如何迭代，都是Iterator接口规范的。

ArrayList实现类的全局变量解析
ArrayList继承于抽象AbstractList类 ，实现了 List接口，RandomAccess接口，Cloneable接口，java.io.Serializable接口。

1、RandomAccess 接口： 表明实现这个这个接口的 List 集合是支持快速随机访问的。在 ArrayList中，我们即可以通过元素的序号快速获取元素对象。
2、Cloneable接口： 覆盖重写了clone()函数，即支持复制克隆操作
3、java.io.Serializable接口： 支持序列化，可以通过序列化后进行传输。

 public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
    
    
	// 序列化
	private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 默认初始化容量，如果超过了这个容量，会自动扩展为原来的1.5倍。
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 用于空实例的共享空数组实例。
     */
    private static final Object[] EMPTY_ELEMENTDATA = {
    
    };

    /**
     * 用于默认大小的空实例的共享空数组实例。
     * 我们将其与 EMPTY_ELEMENTDATA区分开来，
     * 以了解添加第一个元素时要膨胀多少。
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
    
    };

    /**
   	 * 保存数据的数组
   	 * ArrayList 的容量就是这个数组缓冲区的长度。
   	 * 非私有以简化嵌套类访问
     */
    transient Object[] elementData; 
    
    /**
     * ArrayList 的大小（它包含的元素数量）。
     */
    private int size;
    }

ArrayList实现类的构造方法

第一种（无参构造方法）：

// 构造一个默认初始容量为10的空列表
 public ArrayList() {
    
    
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

第二种（有参数构造方法：指定初始容量）：

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);
        }
    }

第三种（根据传入的Collection对象进行数据存储）：

 /**
    * 构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
    * 如果指定的集合为null，throws NullPointerException。
    */
public ArrayList(Collection<? extends E> c) {
    
    
		// 将Collection对象转换为Object数组（调用的是Collection接口的方法）
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
    
    
            if (c.getClass() == ArrayList.class) {
    
    
                elementData = a;
            } else {
    
    
            /**
             * 复制指定的数组，截断或填充空值（如有必要），使副本具有指定的长度。
             * 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。
             */
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
    
    
            // 替换为空数组
            elementData = EMPTY_ELEMENTDATA;
        }
    }

ArrayList实现类常用方法解析

add()方法：

// 将指定元素附加到此列表的末尾。
 public boolean add(E e) {
    
    
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

addAll()方法：

public boolean addAll(Collection<? extends E> c) {
    
    
		// 将Collection对象转换为Object数组（调用的是Collection接口的方法）
        Object[] a = c.toArray();
        int numNew = a.length;
        // 计算列表容量。确保内部容量大小足够
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        // 返回添加成功
        return numNew != 0;
    }

在添加元素之前，需要进行剩余空间检查，如果需要则自动扩容。扩容操作最终是通过grow()方法完成的。

set()方法：

由于ArrayList实现类的底层是一个数组，ArrayList的set()方法也就变得非常简单，直接对数组的指定位置赋值即可。

public E set(int index, E element) {
    
    
	//下标越界检查
    rangeCheck(index);
    E oldValue = elementData(index);
    //赋值到指定位置，复制的仅仅是引用
    elementData[index] = element;
    return oldValue;
}

get()方法

代码简单注意类型转换。

public E get(int index) {
    
    
	// 下标越界检测
    rangeCheck(index);
    //返回元素数据 ，注意类型转换
    return (E) elementData[index];
}

remove()方法

删除操作是add()操作的逆过程，需要将删除点之后的元素向前移动一个位置。需要注意的是为了让GC（垃圾回收）起作用，必须显式的为最后一个位置赋null值。
第一个方法（删除指定位置元素）：

public E remove(int index) {
    
    
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        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

        return oldValue;
    }

第二个方法（删除指定元素数据）：

扫描二维码关注公众号，回复： 13771063 查看本文章

 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;
    }

trimToSize()方法：

这个方法提供了将底层数组的容量调整为当前列表保存的实际元素的大小的功能。

 public void trimToSize() {
    
    
        modCount++;
        if (size < elementData.length) {
    
    
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

index()方法

获取元素第一次出现的位置

 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;
    }

获取元素最后一次出现的位置：

public int lastIndexOf(Object o) {
    
    
        if (o == null) {
    
    
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
    
    
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

ArrayList实现类的自动扩容机制

前面提及到ArrayList实现类当没有指定初始容量的时候，它的默认容量为10，当列表中的存储的数据元素个数超过了初始容量，那么它就会自动扩容为原来的1.5倍。（由于底层代码结构把返回容量的函数设置为私有，尝试使用反射的方法获取到ArrayList实现类的私有属性和私有方法，但是貌似私有方法可以访问，私有属性访问为空。所以无法打印查看实际的容量大小。）

实例代码验证（有bug，还请大佬改正一下）：

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;


/**
 * @author: 随风飘的云
 * @date 2022/03/19 10:43
 */
public class ListTest {
    
    
    public static void main(String[] args) throws Exception{
    
    
        // 第一行代码,
        ArrayList<Integer> list = new ArrayList<>();
        // 第二行代码，下面以此类推。
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        list.add(8);
        list.add(9);
        list.add(10);
        System.out.println(list.size());
        list.add(11);
        System.out.println(list.size());

        Class classList = Class.forName("java.util.ArrayList");
        ArrayList obj = (ArrayList) classList.newInstance();
        Method[] method = classList.getDeclaredMethods();
        // 报错，没有这个属性
        Field fields = classList.getField("elementData");
        fields.setAccessible(true);
        // 打印为空
        System.out.println(fields);
        for (Method meth:method) {
    
    
            meth.setAccessible(true);
            //System.out.println(meth);
        }
        Object[] data = new Object[]{
    
    1};
        System.out.println(method[41].invoke(obj, data, 1));
    }
}

代码分析：
首先执行第一行代码，也就是调用ArrayList类的无参构造方法。这个时候的elementData被赋值为默认容量空元素数据DEFAULTCAPACITY_EMPTY_ELEMENTDATA然后执行第二行代码，及添加整形数1，这个时候调用add(E e)方法。

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

然后来到这三个方法里执行

1、calculateCapacity(Object[] elementData, int minCapacity)
2、ensureCapacityInternal(int minCapacity)
3、ensureExplicitCapacity(int minCapacity)

// 计算容量方法
 private static int calculateCapacity(Object[] elementData, int minCapacity) {
    
    
 		// 当elementData为默认容量空元素数据，设置为默认的长度10.
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    
    
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
// 确保内部容量（add函数之后的最先调用）
    private void ensureCapacityInternal(int minCapacity) {
    
    
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
	// 确保显式容量
    private void ensureExplicitCapacity(int minCapacity) {
    
    
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

代码执行流程：
经过上面的分析，可以看出大概的流程是这样的。首先创建ArrayList实现类对象，然后往列表里面添加元素。执行add(E e)方法过程中。程序首先调用ensureCapacityInternal方法，这个方法需要传入一个最小容量参数minCapacity，在add()方法内传入的最小容量参数是每次添加元素的长度加一（size+1）。执行ensureCapacityInternal方法，首先是计算容量，具体可看上面三个方法的源码分析。计算完容量就是确保显示容量，显示容量里面有一个属性modCount，这个属性是属于AbstractList抽象类的。当最小容量减去元素数据长度大于0(minCapacity - elementData.length > 0)时，进行列表容量扩容。当列表中添加了整数1，此时最小容量参数minCapacity为10，当列表中添加了整数2，这个时候的元素数据elementData不等于默认容量空元素数据DEFAULTCAPACITY_EMPTY_ELEMENTDATA，这个时候返回的最下容量参数minCapacity为2，因为添加整数2时执行add()方法时传入的最下容量参数是size+1 等于2，此时elementData有数据，不可以执行Math.max(DEFAULT_CAPACITY, minCapacity)这行代码。

一句话总结： 未添加原始数据时，可以理解列表为空，这个时候添加的第一个元素会导致初始化最小容量为10，当后面元素添加的时候，返回的最小容量参数minCapacity 是数据长度，这个时候的最小容量减去元素数据长度大于0(minCapacity - elementData.length > 0)总是不成立，当元素长度添加到11的时候，最小容量减去元素数据长度大于0(minCapacity - elementData.length > 0)成立，执行扩容函数grow()（一句话有点长了）

/**
 * 增加容量以确保它至少可以容纳最小容量参数指定的元素数量。
 */ 
private void grow(int minCapacity) {
    
    
        // 旧的数据长度为当前元素数据长度
        int oldCapacity = elementData.length;
        // 新的数据长度为旧的数据长度加旧的数据长度右移位，相当于除以2.（>>为有符号的位移动）
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 调用Arrays.copyOf()方法
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

Arrays.copyOf()方法

  public static int[] copyOf(int[] original, int newLength) {
    
    
        int[] copy = new int[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

Arrays.copyOf()方法使用实例：

import java.util.Arrays;


/**
 * @author: 随风飘的云
 * @date 2022/03/19 10:43
 */
public class ListTest {
    
    
    public static void main(String[] args) throws Exception{
    
    
        int[] list = new int[]{
    
    1,2,3};
        System.out.println(list.length);
        // 可以理解为扩容
        System.out.println(Arrays.copyOf(list, 10).length);
    }
}

结果：

ArrayList实现类源码解读（来自JavaGuide）：

package java.util;

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;


public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    
    
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 默认初始容量大小
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空数组（用于空实例）。
     */
    private static final Object[] EMPTY_ELEMENTDATA = {
    
    };

     //用于默认大小空实例的共享空数组实例。
      //我们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多少。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
    
    };

    /**
     * 保存ArrayList数据的数组
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * ArrayList 所包含的元素个数
     */
    private int size;

    /**
     * 带初始容量参数的构造函数（用户可以在创建ArrayList对象时自己指定集合的初始大小）
     */
    public ArrayList(int initialCapacity) {
    
    
        if (initialCapacity > 0) {
    
    
            //如果传入的参数大于0，创建initialCapacity大小的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
    
    
            //如果传入的参数等于0，创建空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
    
    
            //其他情况，抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    /**
     *默认无参构造函数
     *DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为0.初始化为10，也就是说初始其实是空数组 当添加第一个元素的时候数组容量才变成10
     */
    public ArrayList() {
    
    
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
     */
    public ArrayList(Collection<? extends E> c) {
    
    
        //将指定集合转换为数组
        elementData = c.toArray();
        //如果elementData数组的长度不为0
        if ((size = elementData.length) != 0) {
    
    
            // 如果elementData不是Object类型数据（c.toArray可能返回的不是Object类型的数组所以加上下面的语句用于判断）
            if (elementData.getClass() != Object[].class)
                //将原来不是Object类型的elementData数组的内容，赋值给新的Object类型的elementData数组
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
    
    
            // 其他情况，用空数组代替
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

    /**
     * 修改这个ArrayList实例的容量是列表的当前大小。 应用程序可以使用此操作来最小化ArrayList实例的存储。
     */
    public void trimToSize() {
    
    
        modCount++;
        if (size < elementData.length) {
    
    
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }
//下面是ArrayList的扩容机制
//ArrayList的扩容机制提高了性能，如果每次只扩充一个，
//那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。
    /**
     * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量
     * @param   minCapacity   所需的最小容量
     */
    public void ensureCapacity(int minCapacity) {
    
    
        //如果是true，minExpand的值为0，如果是false,minExpand的值为10
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;
        //如果最小容量大于已有的最大容量
        if (minCapacity > minExpand) {
    
    
            ensureExplicitCapacity(minCapacity);
        }
    }
   //1.得到最小扩容量
   //2.通过最小容量扩容
    private void ensureCapacityInternal(int minCapacity) {
    
    
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    
    
              // 获取“默认的容量”和“传入参数”两者之间的最大值
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
  //判断是否需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
    
    
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            //调用grow方法进行扩容，调用此方法代表已经开始扩容了
            grow(minCapacity);
    }

    /**
     * 要分配的最大数组大小
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * ArrayList扩容的核心方法。
     */
    private void grow(int minCapacity) {
    
    
        // oldCapacity为旧容量，newCapacity为新容量
        int oldCapacity = elementData.length;
        //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
        //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //再检查新容量是否超出了ArrayList所定义的最大容量，
        //若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
        //如果minCapacity大于MAX_ARRAY_SIZE，则新容量则为Interger.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE。
        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);
    }
    //比较minCapacity和 MAX_ARRAY_SIZE
    private static int hugeCapacity(int minCapacity) {
    
    
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    /**
     *返回此列表中的元素数。
     */
    public int size() {
    
    
        return size;
    }

    /**
     * 如果此列表不包含元素，则返回 true 。
     */
    public boolean isEmpty() {
    
    
        //注意=和==的区别
        return size == 0;
    }

    /**
     * 如果此列表包含指定的元素，则返回true 。
     */
    public boolean contains(Object o) {
    
    
        //indexOf()方法：返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1
        return indexOf(o) >= 0;
    }

    /**
     *返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-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++)
                //equals()方法比较
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。.
     */
    public int lastIndexOf(Object o) {
    
    
        if (o == null) {
    
    
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
    
    
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * 返回此ArrayList实例的浅拷贝。 （元素本身不被复制。）
     */
    public Object clone() {
    
    
        try {
    
    
            ArrayList<?> v = (ArrayList<?>) super.clone();
            //Arrays.copyOf功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制的长度
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
    
    
            // 这不应该发生，因为我们是可以克隆的
            throw new InternalError(e);
        }
    }

    /**
     *以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
     *返回的数组将是“安全的”，因为该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。
     *因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。
     */
    public Object[] toArray() {
    
    
        return Arrays.copyOf(elementData, size);
    }

    /**
     * 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）;
     *返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。
     *否则，将为指定数组的运行时类型和此列表的大小分配一个新数组。
     *如果列表适用于指定的数组，其余空间（即数组的列表数量多于此元素），则紧跟在集合结束后的数组中的元素设置为null 。
     *（这仅在调用者知道列表不包含任何空元素的情况下才能确定列表的长度。）
     */
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
    
    
        if (a.length < size)
            // 新建一个运行时类型的数组，但是ArrayList数组的内容
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
            //调用System提供的arraycopy()方法实现数组之间的复制
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

    // Positional Access Operations

    @SuppressWarnings("unchecked")
    E elementData(int index) {
    
    
        return (E) elementData[index];
    }

    /**
     * 返回此列表中指定位置的元素。
     */
    public E get(int index) {
    
    
        rangeCheck(index);

        return elementData(index);
    }

    /**
     * 用指定的元素替换此列表中指定位置的元素。
     */
    public E set(int index, E element) {
    
    
        //对index进行界限检查
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        //返回原来在这个位置的元素
        return oldValue;
    }

    /**
     * 将指定的元素追加到此列表的末尾。
     */
    public boolean add(E e) {
    
    
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //这里看到ArrayList添加元素的实质就相当于为数组赋值
        elementData[size++] = e;
        return true;
    }

    /**
     * 在此列表中的指定位置插入指定的元素。
     *先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大；
     *再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
     */
    public void add(int index, E element) {
    
    
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //arraycopy()这个实现数组之间复制的方法一定要看一下，下面就用到了arraycopy()方法实现数组自己复制自己
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

    /**
     * 删除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。
     */
    public E remove(int index) {
    
    
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        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
      //从列表中删除的元素
        return oldValue;
    }

    /**
     * 从列表中删除指定元素的第一个出现（如果存在）。 如果列表不包含该元素，则它不会更改。
     *返回true，如果此列表包含指定的元素
     */
    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;
    }

    /*
     * Private remove method that skips bounds checking and does not
     * return the value removed.
     */
    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
    }

    /**
     * 从列表中删除所有元素。
     */
    public void clear() {
    
    
        modCount++;

        // 把数组中所有的元素的值设为null
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

    /**
     * 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
     */
    public boolean addAll(Collection<? extends E> c) {
    
    
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

    /**
     * 将指定集合中的所有元素插入到此列表中，从指定的位置开始。
     */
    public boolean addAll(int index, Collection<? extends E> c) {
    
    
        rangeCheckForAdd(index);

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

        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;
    }

    /**
     * 从此列表中删除所有索引为fromIndex （含）和toIndex之间的元素。
     *将任何后续元素移动到左侧（减少其索引）。
     */
    protected void removeRange(int fromIndex, int toIndex) {
    
    
        modCount++;
        int numMoved = size - 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;
        }
        size = newSize;
    }

    /**
     * 检查给定的索引是否在范围内。
     */
    private void rangeCheck(int index) {
    
    
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
     * add和addAll使用的rangeCheck的一个版本
     */
    private void rangeCheckForAdd(int index) {
    
    
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
     * 返回IndexOutOfBoundsException细节信息
     */
    private String outOfBoundsMsg(int index) {
    
    
        return "Index: "+index+", Size: "+size;
    }

    /**
     * 从此列表中删除指定集合中包含的所有元素。
     */
    public boolean removeAll(Collection<?> c) {
    
    
        Objects.requireNonNull(c);
        //如果此列表被修改则返回true
        return batchRemove(c, false);
    }

    /**
     * 仅保留此列表中包含在指定集合中的元素。
     *换句话说，从此列表中删除其中不包含在指定集合中的所有元素。
     */
    public boolean retainAll(Collection<?> c) {
    
    
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }


    /**
     * 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
     *指定的索引表示初始调用将返回的第一个元素为next 。 初始调用previous将返回指定索引减1的元素。
     *返回的列表迭代器是fail-fast 。
     */
    public ListIterator<E> listIterator(int index) {
    
    
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }

    /**
     *返回列表中的列表迭代器（按适当的顺序）。
     *返回的列表迭代器是fail-fast 。
     */
    public ListIterator<E> listIterator() {
    
    
        return new ListItr(0);
    }

    /**
     *以正确的顺序返回该列表中的元素的迭代器。
     *返回的迭代器是fail-fast 。
     */
    public Iterator<E> iterator() {
    
    
        return new Itr();
    }