Java 集合：（五） List实现类：ArrayList

一、ArrayList 概述

　　1、ArrayList 是 List 接口的典型实现类、主要实现类；

　　2、ArrayList 是 List 接口的一个实现类，也是 Java 中最常用的容器实现类之一，可以把它理解为「可变数组」。

　　3、Java 中的数组初始化时需要指定长度，而且指定后不能改变。ArrayList 内部也是一个数组，它对数组的功能做了增强：主要是在容器内元素增加时可以动态扩容，这也是 ArrayList 的核心所在。

　　4、学习了 List 接口的方法，ArrayList 的主要方法与 List 基本一致，因此这里重点分析其内部结构和扩容的原理。

　　5、ArrayList 的继承结构如下（省略部分接口）：

　　　　

二、实现的接口

　　源码：

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

 　   （1）List 接口：该接口定义了 List 接口里面常用的操作方法；

　　（2）RandomAccess接口：接⼝中什么都没有定义，RandomAccess 接⼝不过是⼀个标识罢了。标识什么？ 标识实现这个接⼝的类具有随机访问功能。RandomAccess 是一个标志接口，表明实现这个这个接口的 List 集合是支持快速随机访问的。在 ArrayList 中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。

　　（3）Cloneable接口：实现了 Cloneable 接口，并重写了 clone()方法，表示该实现类是支持克隆的；

　　（4）Serializable 接口：该接口中也什么都没有定义，该接口也只是一个标识，表明当前的类支持序列化，能够通过序列化去传输。

　　

三、成员变量

　　先来看一下 ArrayList 中的成员变量：

　　JDK8的1.8.0_291 版本中：

private static final long serialVersionUID = 8683452581122892189L;

/**
 * Default initial capacity.
 */
private static final int DEFAULT_CAPACITY = 10;   //默认容量 10

/**
 * Shared empty array instance used for empty instances.
 */
private static final Object[] EMPTY_ELEMENTDATA = {};  //空元素数据

/**
 * Shared empty array instance used for default sized empty instances. We
 * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
 * first element is added.
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};   //默认容量空元素数据

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 * will be expanded to DEFAULT_CAPACITY when the first element is added.
 */
transient Object[] elementData; // non-private to simplify nested class access  存储数据的数组

/**
 * The size of the ArrayList (the number of elements it contains).
 *
 * @serial
 */
private int size;       //有效元素的个数

/**
 * The maximum size of array to allocate.
 * Some VMs reserve some header words in an array.
 * Attempts to allocate larger arrays may result in
 * OutOfMemoryError: Requested array size exceeds VM limit
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

　　JDK7 高阶版本中：

　　private static final long serialVersionUID = 8683452581122892189L;

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;   //默认容量10

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == EMPTY_ELEMENTDATA will be expanded to
     * DEFAULT_CAPACITY when the first element is added.
     */
    private transient Object[] elementData;

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;

    /**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

 　　JDK7 低级版本以及之前：

 　　private static final long serialVersionUID = 8683452581122892189L;

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer.
     */
    private transient Object[] elementData;

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;

四、构造器（JDK8[1.8.0_291]）

　　我们先从构造器进行分析。

　　ArrayList 有三个构造器，下面进行学习：

　　1、无参构造器

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

　　　　该构造器涉及两个变量：elementData 和 DEFAULTCAPACITY_EMPTY_ELEMENTDATA。

　　　　可以看到上面对这两个成员变量的声明：

　　transient Object[] elementData; // non-private to simplify nested class access
    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

　　　　可以看到 elementData 是一个 Object[] 类型的数组，该数组也是ArrayList 作为容器用于存储数据的地方。

　　　　DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是一个 Object 类型的空数组。

　　　　因此，该无参构造器的作用就是将 elementData 初始化为一个 Object 类型的空数组。

　　2、指定初始化容量的构造器

　　　　该构造传入一个参数，即初始化内部数组容量的 initialCapacity，代码如下：

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

　　　　当初始化容量为 0 时，elementData 被初始化为 EMPTY_ELEMENTDATA，该变量如下：

private static final Object[] EMPTY_ELEMENTDATA = {};

　　　　　该数组与 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 都是一个空的 Object 数组，二者名字不同是为了区分 ArrayList 初始化时是否指定了容量，后期进行扩容的时候有所不同。

　　　　部分版本如下：

    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

　　　　该构造器根据传入的初始容量（initialCapacity）初始化用于存储元素的数组 elementData 变量。

　　　　

　　3、指定初始化集合的构造器

　　　　该构造器传入一个集合 Collection，即使用 Collection 中的元素初始化 ArrayList 对象，代码如下：

　　public ArrayList(Collection<? extends E> c) {
        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 {
            // replace with empty array.
            elementData = EMPTY_ELEMENTDATA;
        }
    }

　　　　部分版本如下：

    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

　　　　 注意：这里若 Collection 为空时会抛出 NPE，因此初始化前有必要判空。

五、构造器（JDK7[1.7.0_7]）

 　   1、无参构造

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this(10);
    }

　　　　　　可以看到，这里是创建了一个容量为10的ArrayList。

　　2、指定初始化容量的构造器

    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

　　3、指定初始化集合的构造器

　　　　源码：

    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

六、ArrayList 扩容机制分析

　　1、先从 ArrayList 的构造函数说起

　　　　（JDK8）ArrayList 有三种方式来初始化，构造方法源码如下：

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


    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     *默认构造函数，使用初始容量10构造一个空列表(无参数构造)
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 带初始容量参数的构造函数。（用户自己指定容量）
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {//初始容量大于0
            //创建initialCapacity大小的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {//初始容量等于0
            //创建空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {//初始容量小于0，抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }


   /**
    *构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
    *如果指定的集合为null，throws NullPointerException。
    */
     public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

　　　　可以发现以无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10。 下面在我们分析 ArrayList 扩容时会讲到这一点内容！

　　　　注意：JDK7 new无参构造的ArrayList对象时，直接创建了长度是10的Object[]数组elementData 。jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式。JDK8的内存优化也值得我们在平时开发中学习。

　　2、一步一步分析 ArrayList 扩容机制

　　　　这里以无参构造函数创建的 ArrayList 为例分析

　　　　（1）先来看 add 方法（addAll()方法类似）

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

　　　　　　　　可以看到，在 add() 方法执行时，会首先执行  ensureCapacityInternal() 方法：（确保内部容量够用）

　　　　　　　　注意 ：JDK11 移除了 ensureCapacityInternal() 和 ensureExplicitCapacity() 方法

　　　　（2）再来看看 ensureCapacityInternal() 方法

　　　　　　（JDK7）可以看到 add 方法 首先调用了ensureCapacityInternal(size + 1)

   //得到最小扩容量
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
              // 获取默认的容量和传入参数的较大值
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

 　　　　　　　　Tip：此处和后续 JDK8 代码格式化略有不同，核心代码基本一样。

　　　　　　（JDK8）可以看到 add 方法中首先调用了ensureCapacityInternal(size + 1)

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

 　　　　　　当 要 add 进第 1 个元素时，minCapacity 为 1，在 Math.max()方法比较后，minCapacity 为 10。

　　　　　  这里只会在使用无参构造器初始化，并且第一次使用 add 方法时执行（将容量初始化为 10）

　　　　（3）ensureExplicitCapacity()方法（确保明确的容量）

　　　　　　 如果调用 ensureCapacityInternal() 方法就一定会进入（执行）这个方法，下面我们来研究一下这个方法的源码！

 　　//判断是否需要扩容  minCapacity 为所需最小容量
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

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

　　　　我们来仔细分析一下：

• • • 当我们要 add 进第 1 个元素到 ArrayList 时，elementData.length 为 0 （因为还是一个空的 list），因为执行了 ensureCapacityInternal() 方法 ，所以 minCapacity 此时为 10。此时，minCapacity - elementData.length > 0成立，所以会进入 grow(minCapacity) 方法。

    • 当 add 第 2 个元素时，minCapacity 为 2，此时 e lementData.length(容量)在添加第一个元素后扩容成 10 了。此时，minCapacity - elementData.length > 0 不成立，所以不会进入 （执行）grow(minCapacity) 方法。

    • 添加第 3、4···到第 10 个元素时，依然不会执行 grow 方法，数组容量都为 10。

　　　　　　直到添加第 11 个元素，minCapacity(为 11)比 elementData.length（为 10）要大。进入 grow 方法进行扩容。

　　　　（4）grow()方法

 　/**
     * 要分配的最大数组大小
     */
    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;
       // 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，
       //如果minCapacity大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
        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);
    }

　　int newCapacity = oldCapacity + (oldCapacity >> 1)，所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍左右（oldCapacity 为偶数就是 1.5 倍，否则是 1.5 倍左右）！ 奇偶不同，比如 ：10+10/2 = 15, 33+33/2=49。如果是奇数的话会丢掉小数.

">>"（移位运算符）：>>1 右移一位相当于除 2，右移 n 位相当于除以 2 的 n 次方。这里 oldCapacity 明显右移了 1 位所以相当于 oldCapacity /2。对于大数据的 2 进制运算，位移运算符比那些普通运算符的运算要快很多，因为程序仅仅移动一下而已，不去计算，这样提高了效率，节省了资源

　　我们再来通过例子探究一下grow() 方法 ：

• 　当 add 第 1 个元素时，oldCapacity 为 0，经比较后第一个 if 判断成立，newCapacity = minCapacity(为 10)。但是第二个 if 判断不会成立，即 newCapacity 不比 MAX_ARRAY_SIZE 大，则不会进入 hugeCapacity 方法。数组容量为 10，add 方法中 return true,size 增为 1。

• 　当 add 第 11 个元素进入 grow 方法时，newCapacity 为 15，比 minCapacity（为 11）大，第一个 if 判断不成立。新容量没有大于数组最大 size，不会进入 hugeCapacity 方法。数组容量扩为 15，add 方法中 return true，size 增为 11。

• 　以此类推······

　　　　由此可以看出，新容量为原容量的 1.5 倍；

　　　　若扩容为 1.5 倍后，仍未达到所需容量，则直接使用所需要的容量。

　　　　可以发现是调用了 Arrays 类的 copyOf() 方法，进入 copyOf() 方法，发现最终调用了 System.arraycopy() 方法：

　　这里补充一点比较重要，但是容易被忽视掉的知识点：

• • 　java 中的 length属性是针对数组说的,比如说你声明了一个数组，想知道这个数组的长度则用到了 length 这个属性.

  • 　java 中的 length() 方法是针对字符串说的，如果想看这个字符串的长度则用到 length() 这个方法.

  • 　java 中的 size() 方法是针对泛型集合说的，如果想看这个泛型有多少个元素，就调用此方法来查看!

　　　　（5）hugeCapacity()方法（巨大的容量）

从上面 grow() 方法源码我们知道： 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) hugeCapacity() 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，如果 minCapacity 大于最大容量，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8。

　　private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        //对minCapacity和MAX_ARRAY_SIZE进行比较
        //若minCapacity大，将Integer.MAX_VALUE作为新数组的大小
        //若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小
        //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

　　3、System.arraycopy()和 Arrays.copyOf()方法

　　　　阅读源码的话，我们就会发现 ArrayList 中大量调用了这两个方法。比如：我们上面讲的扩容操作以及add(int index, E element)、toArray() 等方法中都用到了该方法！

　　　　（1）System.arraycopy()方法

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

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //arraycopy()方法实现数组自己复制自己
        //elementData:源数组;index:源数组中的起始位置;elementData：目标数组；index + 1：目标数组中的起始位置； size - index：要复制的数组元素的数量；
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        size++;
    }

 　　　　　　System.arraycopy() 源码：

    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

　　　　　　我们写一个简单的方法测试以下：

public class ArraycopyTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a = new int[10];
        a[0] = 0;
        a[1] = 1;
        a[2] = 2;
        a[3] = 3;
        System.arraycopy(a, 2, a, 3, 3);
        a[2]=99;
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

}

　　结果：

0 1 99 2 3 0 0 0 0 0

　　　　（2）Arrays.copyOf()方法

　　/**
     以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。
     */
    public Object[] toArray() {
    //elementData：要复制的数组；size：要复制的长度
        return Arrays.copyOf(elementData, size);
    }

 　　　　　　Arrays.copyOf()源码：

    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }
    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

　　个人觉得使用 Arrays.copyOf()方法主要是为了给原有数组扩容，测试代码如下：

public class ArrayscopyOfTest {

    public static void main(String[] args) {
        int[] a = new int[3];
        a[0] = 0;
        a[1] = 1;
        a[2] = 2;
        int[] b = Arrays.copyOf(a, 10);
        System.out.println("b.length"+b.length);
    }
}

　　　　结果：

10

　　　　（3）两者联系和区别

　　　　　　联系：

　　　　　　　　看两者源代码可以发现 copyOf()内部实际调用了 System.arraycopy() 方法

　　　　　　区别：

　　　　　　　　arraycopy() 需要目标数组，将原数组拷贝到你自己定义的数组里或者原数组，而且可以选择拷贝的起点和长度以及放入新数组中的位置 copyOf() 是系统自动在内部新建一个数组，并返回该数组。

　　4、ensureCapacity方法

　　　　　　ArrayList 源码中有一个 ensureCapacity 方法不知道大家注意到没有，这个方法 ArrayList 内部没有被调用过，所以很显然是提供给用户调用的，那么这个方法有什么作用呢？

 /**
    如有必要，增加此 ArrayList 实例的容量，以确保它至少可以容纳由minimum capacity参数指定的元素数。
     *
     * @param   minCapacity   所需的最小容量
     */
    public void ensureCapacity(int minCapacity) {
        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);
        }
    }

　　　　　　最好在 add 大量元素之前用 ensureCapacity 方法，以减少增量重新分配的次数

　　　　　　我们通过下面的代码实际测试以下这个方法的效果：

public class EnsureCapacityTest {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        final int N = 10000000;
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < N; i++) {
            list.add(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用ensureCapacity方法前："+(endTime - startTime));

    }
}

　　　　运行结果：

使用ensureCapacity方法前：2158

public class EnsureCapacityTest {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        final int N = 10000000;
        list = new ArrayList<Object>();
        long startTime1 = System.currentTimeMillis();
        list.ensureCapacity(N);
        for (int i = 0; i < N; i++) {
            list.add(i);
        }
        long endTime1 = System.currentTimeMillis();
        System.out.println("使用ensureCapacity方法后："+(endTime1 - startTime1));
    }
}

　　　　　　运行结果：

使用ensureCapacity方法前：1773

　　　　　　通过运行结果，我们可以看出向 ArrayList 添加大量元素之前最好先使用ensureCapacity 方法，以减少增量重新分配的次数。

 

　　5、扩容小结

　　　　（1） 若未指定初始化容量

　　　　　　当第一次执行 add() 方法时，将数组长度默认初始化为 10，之后再添加元素时不扩容，直至容量等于 10，再添加第 11 个元素时，将容量扩容为 15 (10 + 10 >> 1)，以此类推。

 

　　　　（2） 若指定了初始化容量 initialCapacity

　　　　　　当数组容量到达 initialCapacity 之前，不进行扩容，当容量等于 initialCapacity 时若再添加元素，则执行扩容，扩容操作同上。

 

　　　　（3）  新容量大小

　　　　　　默认扩容后数组的容量为原数组容量的 1.5 倍；若仍未达到所需大小（使用 addAll() 方法时可能出现），则扩容为所需的容量。

　　　　（4）jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

　　　　（5）建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)

七、其他常用方法

　　1、add(int index, E element)

　　　　源码分析：

    public void add(int index, E element) {
        rangeCheckForAdd(index);  //范围检查
        
        //查看是否需要进行扩容，同扩容原理
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        
        //把 elementData 数组中从 index 开始移动到 index+1的位置，移动了 size - index 个元素，即空出来 index 改位置
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
    
    //该方法是为了 add() 和 addAll() 方法所进行的索引校验
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

　　2、addAll(Collection<? extends E> c) 

　　　　源码分析：

    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();   // 把集合 c 转成 数组
        int numNew = a.length;      // 获取数组长度
        //是否需要扩容，确保内部容量
        ensureCapacityInternal(size + numNew);  // Increments modCount
        //将数组 a 从开始位置全部复制到 elementData 的 后面，复制了 numNew 个元素
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;             //加上添加集合的长度
        return numNew != 0;
    }

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

 　　　　源码分析：

    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);       //范围检查

        Object[] a = c.toArray();      //将 集合 c 转成 数组
        int numNew = a.length;         //获取数组的长度
        
        //是否需要扩容，确保内部容量
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;    //计算需要移动多少个元素
        if (numMoved > 0)
            //把 elementData 数组从 index开始移动，移动到 index+numNew的位置，移动了 numMoved个元素，即为 数组a 空出地方
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
        //再把数组 a 的全部元素复制到 elementData中，以index为起始位置，复制了数组a的长度numNew 个
        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));
    }

　　4、get(int index)

　　　　源码分析：

    public E get(int index) {
        rangeCheck(index);  //范围检查，index 是否合理

        return elementData(index); //获取元素
    }
    
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    
    E elementData(int index) {
        return (E) elementData[index];
    }

　　5、set(int index, E element)

　　　　源码分析：

    public E set(int index, E element) {
        rangeCheck(index);               //范围检查

        E oldValue = elementData(index); //获取当前索引的值
        elementData[index] = element;    //给索引设置新的值
        return oldValue;                 //返回旧值
    }
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    E elementData(int index) {
        return (E) elementData[index];
    }

　　6、remove(int index)

　　　　源码分析：

    public E remove(int index) {
        rangeCheck(index);    //范围检查

        modCount++;
        E oldValue = elementData(index);  //获取index位置的值

        int numMoved = size - index - 1;  //需要移动的元素个数
        if (numMoved > 0)
            //把 elementData 数组中从 index+1 位置移动到 index 位置，移动 numMoved 个元素
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work   让GC快速执行

        return oldValue;                 //返回旧值
    }
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

　　7、remove(Object o)

　　　　源码分析：

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

　　　　可以看到如果根据元素进行移除，都是先找到元素所对应的位置，然后再进行删除。

　　8、removeAll(Collection<?> c)

　　　　源码分析：

    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);   //要求非空判断
        return batchRemove(c, false);
    }
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            //遍历整个集合 elementData
            for (; r < size; r++)
                //如果 集合 c 中不包含 elementData[r]，则把该元素保存下来
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            //无论 contains() 是否抛出异常，只要 r!=size，就把 r到size的元素移动到elementData的w位置之后，移动 size-r个元素
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;   //elementData 中有效元素个数：w + size - r
            }
            //只要 w != size,就把 elementData 中 w 到 size 位置都设为 null，方便 GC 快速工作
            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 次
                size = w;               //elementData 中有效元素个数为 w
                modified = true;
            }
        }
        return modified;
    }

removeAll和remove方法思想也是类似的，但是这里有个细节我认为作者处理的非常妙，有必要拿出来品味一下。那么妙在哪里呢？原来这里有两个方法removeAll和retainAll他们正好是互斥的两个操作，但是底层都调用了同一个方法来实现，请看！ 

// 删除包含集合C的元素
publicboolean removeAll(Collection<?> c){
    Objects.requireNonNull(c);
    return batchRemove(c,false);
}

// 除了包含集合C的元素外，一律被删除。也就是说，最后只剩下c中的元素。
publicboolean retainAll(Collection<?> c){
    Objects.requireNonNull(c);
    return batchRemove(c,true);
}

private boolean batchRemove(Collection<?> c,boolean complement){
    final Object[] elementData =this.elementData;
    int r =0, w =0;
    boolean modified =false;
    try{
        for(; r < size; r++)
            // 在这里有两点值得我们学习
            // 第一，作者巧妙的提取了逻辑上的最大公约数，仅通过一行逻辑判断就实现了两个互斥的效果。
            // 第二，作者的所用操作都集中于elementData一个数组上，避免了资源的浪费。
            if(c.contains(elementData[r])== complement)
                elementData[w++]= elementData[r];
    }finally{
        // 理论上r==size 只有当出现异常情况的时候，才会出现r!=size，一旦出现了异常，
        // 那么务必要将之前被修改过的数组再还原回来。
        if(r != size){
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        
        if(w != size){
            // 被删除部分数组后，剩余的所有元素被移到了0-w之间的位置，w位置以后的元素都被置空回收。
            for(int i = w; i < size; i++)
                elementData[i]=null;
            modCount += size - w;
            size = w;
            modified =true;
        }
    }
    return modified;
}

　　9、retainAll(Collection<?> c)

　　　　源码分析：

    //计算集合的交集，对集合 c 不会有影响
    public boolean retainAll(Collection<?> c) {    
        Objects.requireNonNull(c);       //要求非空判断
        return batchRemove(c, true);
    }
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            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;
    }

　　10、indexOf(Object o)

　　　　源码分析：

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

　　　　indexOf() 就是从头开始遍历整个数组，查看是否能够找到与之匹配的元素，找到返回索引下标，找不到返回 -1。

　　11、lastIndexOf(Object o)

　　　　源码分析：

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

　　　　lastIndexOf() 原理同 indexOf()，只是此时从数组尾部开始进行遍历。

　　12、subList(int fromIndex, int toIndex)：返回的是原集合的一个子集合（视图）

　　　　源码分析：

    public List<E> subList(int fromIndex, int toIndex) {
        subListRangeCheck(fromIndex, toIndex, size);    //范围检查
        return new SubList(this, 0, fromIndex, toIndex); //包括 fromIndex 不包含 toIndex
    }
    
    static void subListRangeCheck(int fromIndex, int toIndex, int size) {
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
        if (toIndex > size)
            throw new IndexOutOfBoundsException("toIndex = " + toIndex);
        if (fromIndex > toIndex)
            throw new IllegalArgumentException("fromIndex(" + fromIndex +
                                               ") > toIndex(" + toIndex + ")");
    }
    
    //私有内部类，List接口 AbstractList接口的实现类，但不等于 ArrayList
    private class SubList extends AbstractList<E> implements RandomAccess {
        private final AbstractList<E> parent;
        private final int parentOffset;
        private final int offset;
        int size;
    }
    //构造器
    SubList(AbstractList<E> parent,
                int offset, int fromIndex, int toIndex) {
            this.parent = parent;
            this.parentOffset = fromIndex;
            this.offset = offset + fromIndex;
            this.size = toIndex - fromIndex;     //从 fromIndex 开始计算，移动size个
            this.modCount = ArrayList.this.modCount;
    }

 这里指的子集，就是指定list的起始位置和结束位置，获取这段范围内的集合元素。那么这有什么作用呢？当单独获取了这段子集以后，就可以独立的对待他，他的起始元素将从0开始。那么这是怎么实现的呢？原来他是通过维护一个SubList内部类，每次读取元素的时候，配合一个offset偏移量，精确的找到elementData数组中对应位置的元素了。

　　13、replaceAll(UnaryOperator<E> operator)

　　　　源码分析：

    public void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);  //要求非空判断
        final int expectedModCount = modCount;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            elementData[i] = operator.apply((E) elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

　　14、序列化方法：writeObject(java.io.ObjectOutputStream s)

　　　　源码分析：

    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

　　15、反序列化方法：readObject(java.io.ObjectInputStream s)

　　　　源码分析：

　　private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

　　16、迭代器

　　　　在java集合类中，所有的集合都实现了Iterator接口，而List接口同时实现了ListIterator接口，这就决定了ArrayList他同时拥有两种迭代遍历的基因—Itr和ListItr。

　　　　（1）Itr

　　　　　　Itr实现的是Iterator接口，拥有对元素向后遍历的能力

int cursor;// 指向下一个返回的元素
int lastRet =-1;// 指向在遍历过程中，最后返回的那个元素。 如果没有为-1。

public boolean hasNext() {
    return cursor != size;
}

public E next(){
    checkForComodification();
    int i = cursor;
    if(i >= size)
        thrownewNoSuchElementException();
    Object[] elementData =ArrayList.this.elementData;
    if(i >= elementData.length)
        throw new ConcurrentModificationException();
    // 指向下一个元素
    cursor = i +1;
    // 返回当前元素，并把lastRet指向当前这个元素
    return(E) elementData[lastRet = i];
}


// 此处有坑，调用此方法前，必须调用next方法，从lastRet可以看出，如果当前没有调用next，那么lastRet==-1
publicvoid remove(){
    if(lastRet <0)
        thrownewIllegalStateException();
    checkForComodification();
    try{
        ArrayList.this.remove(lastRet);
        cursor = lastRet;
        lastRet =-1;
        expectedModCount = modCount;
    }catch(IndexOutOfBoundsException ex){
        throw new ConcurrentModificationException();
    }
}

　　　　（2）ListItr

　　　　　　ListItr不但继承了Itr类，也实现了ListIterator接口，因此他拥有双向遍历的能力。这里着重介绍一下向前遍历的原理。

public boolean hasPrevious(){
    return cursor !=0;
}

public int previousIndex(){
    // 通过cursor-1，将指针向前移位。
    return cursor -1;
}
public E previous(){
    checkForComodification();
    int i = cursor -1;
    if(i <0)
        throw new NoSuchElementException();
    Object[] elementData =ArrayList.this.elementData;
    if(i >= elementData.length)
        throw new ConcurrentModificationException();
    cursor = i;
    return(E) elementData[lastRet = i];
}

　　　　ListItr同时增加了set和add两个方法

// 替换当前遍历到的元素
publicvoidset(E e){
    if(lastRet <0)
        throw new IllegalStateException();
    checkForComodification();
    try{
        ArrayList.this.set(lastRet, e);
    }catch(IndexOutOfBoundsException ex){
        throw new ConcurrentModificationException();
    }
}

// 添加一个元素到当前遍历到的位置
publicvoid add(E e){
    checkForComodification();
    try{
        int i = cursor;
        ArrayList.this.add(i, e);
        cursor = i +1;
        lastRet =-1;
        expectedModCount = modCount;
    }catch(IndexOutOfBoundsException ex){
        throw new ConcurrentModificationException();
    }
}

八、ArrayList 核心源码解读

　　核心源码解读：

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);
        }
    }
   //得到最小扩容量
    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();
    }

}

九、线程安全性

　　1、ArrayList 是线程不安全的

　　　　线程安全可以简单理解为：多个线程同时操作一个方法或变量时，不会出现问题，若出现问题，可认为是线程不安全的。

　　　　ArrayList 是线程不安全的，主要体现有二：

　　　　（1）多个线程往 ArrayList 添加数据时（扩容时），可能会产生数组越界异常（ArrayIndexOutOfBoundsException）;

　　　　（2）多个线程遍历同一个 ArrayList，有线程对其进行修改时，可能会抛出 ConcurrentModificationException。

　　　　先对 add() 方法进行分析：

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

　　　　注意：i++ 操作是非原子性的。

　　2、场景分析一：

　　　　若有一个初始容量为 1 的 ArrayList，线程 T1 和 T2 同时向其中添加元素（add()方法），当添加第2个元素时，需要进行扩容。

　　　　此时若有以下执行时序：

　　　　（1）T1、T2 检测到需要扩容

　　　　　　此时，T1 和 T2 拿到的都是 elementData.length =1,size = 1，若 T1 先执行 ensureCapacityInternal() 方法扩容，则 elementData.length=2，size=1；之后 T2 再执行 ensureCapacityInternal() 方法时，因为初始 size = 1，而 T1 扩容后 elementData.length = 2，所以 T2 不会再进行扩容（不再执行 grow()方法）。

　　　　（2）T1 执行赋值操作和 size++ 操作

　　　　　　之后 T1 执行赋值操作 elementData[1]=XX 和 size++，size自增为2。

　　　　（3）T2 执行赋值操作（数组越界）和 size++操作

　　　　　　由于上一步 T1 执行了 size++操作，当前 size=2，这时的赋值 elementData[size++] 将对 elementData[2] 执行赋值操作，而 elementData.length = 2，最大下标为 1，这时会发生数组越界异常（ArrayIndexOutOfBoundsException）。

　　3、场景分析二：

　　　　有一个 ArrayList，线程 T1 对其进行遍历；线程 T2 对其遍历，并移除部分元素。

　　　　对 ArrayList 进行遍历时，以 iterator 方法为例，其代码如下：

public Iterator<E> iterator() {
    return new Itr();
}

 

　　　　会创建一个内部类 Itr，如下：

private class Itr implements Iterator<E> {
    int expectedModCount = modCount;

    // ...
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    // 检查是否有其他线程进行结构性修改
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

　　　　而 ArrayList的 add()、remove()等结构性修改的操作都会使 modCount++。因此有：若线程 T1 只对 ArrayList 进行遍历；而线程 T2 对同一个 ArrayList 进行了移除元素操作，则会修改 modCount 的值，导致线程 T1 中 modCount != expectedModCount，从而触发 ConcurrentModificationException。

十、总结

　　1、ArrayList 可以理解为 【可以自动扩容的数组】，默认初始化容量为 10，默认每次扩容为原容量的 1.5 倍。

　　2、扩容时会创建一个新的数组，并将之前的元素拷贝到新数组中（因此，若要将数量已知的元素放入 ArrayList，在初始化时指定长度可以避免多次扩容）；

　　3、线程不安全，不适合在多线程场景下使用。