ArrayList的部分源码分析

　　欢迎加入Java交流群 512878347 ，欢迎关注微信公众号 以文在线 。　

　　ArrayList是经常使用的容器，它的底层是采用动态数组实现的，它的容量可以自动增加。ArrayList是一个泛型类，它继承了AbstractList类，实现了List、RandomAccess、Cloneable、Serializable接口，如图1所示。本文从ArrayList的部分源代码入手，详细的讲解了ArrayList的存储结构、改取元素、增删元素等知识。

存储结构

 　　顺序表（sequence list）是线性表的一种，它是在内存中开辟一段连续的存储空间存放元素，它把逻辑上相邻的元素存储在物理位置上相邻的存储单元中（存储单元也称为节点，每一个节点存放一个元素），元素之间的逻辑关系由节点的邻接关系来体现。 

　　数组采用的存储结构是顺序表，ArrayList是使用动态数组实现的。ArrayList内部维护的是一个Object类型的数组elementData，ArrayList的元素就是存储在这个数组中的，参见程序1第11句代码。ArrayList的容量capacity就是数组elementData的长度，ArrayList存储的元素个数size小于等于它的容量capacity，即顺序表中节点的数量大于等于要存储的元素的数量。例如在图2中，ArrayList的元素的个数size为n，容量capacity为n + N，即在内存中开辟了一个节点为n + N的顺序表并用这个顺序表存储了n个元素：第1个节点到第n各节点依次存储了a₁、…、a_i、…、a_n，第n + 1个节点到第n + N个节点没有存储元素。没有存储元素的节点预留下来增加新元素。

成员变量

 　　程序1给出了ArrayList中的成员变量并对这些成员变量进行了说明。 

// 序列化ID
private static final long serialVersionUID = 8683452581122892189L;
// 默认初始容量。
private static final int DEFAULT_CAPACITY = 10;
// 空数组。
private static final Object[] EMPTY_ELEMENTDATA = {};
// 默认容量的空数组。
// 该空数组仅用于在无参构造器中给elementData赋值。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 用于存储元素的数组，ArrayList的容量是该数组的长度。
transient Object[] elementData;
// 元素的个数。
private int size;
/*
 * 数组的最大长度。
 * 少部分虚拟机会在数组中存储头部信息（比如数组的长度），
 * 头部信息会占用一定的内存，将数组的最大长度
 * 设置为Integer.MAX_VALUE - 8是最安全的。
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;  

程序1 成员变量

 　　在ArrayList中还有一个成员变量modCount，该成员变量是从父类AbstractList中继承过来的，它表示列表发生结构上修改的次数，参见程序2。结构上修改是指改变列表中元素的个数，不包含修改元素的值。 

// 列表发生结构上修改的次数。
protected transient int modCount = 0; 

程序2 成员变量modCount 

构造方法 

　　ArrayList类提供了三个构造器：

 　　1、ArrayList (int initialCapacity)：构造一个指定容量的空列表（没有存放元素的列表），参见程序3。 

/**
 * 构造一个指定容量的空列表。
 * 
 * @param initialCapacity 指定容量
 * @return IllegalArgumentException 
           如果指定的容量为负数
 */
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);
   }
}

程序3 构建指定容量的构造器 

　　2、ArrayList ()：使用默认容量的空数组构建一个空列表，参见程序4。 

/**
* 使用DEFAULTCAPACITY_EMPTY_ELEMENTDATA构建一个空列表。
*/
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

程序4 默认构造器 

　　3、ArrayList (Collection<? extends E> c)：构造一个包含给定集合所有元素的列表，并且这些元素在列表中的顺序和给定集合的迭代器返回它们的顺序是一致的，参见程序5。 

/**
 * 构造一个包含给定集合所有元素的列表，并且这些元素在
 * 列表中的顺序和给定集合的迭代器返回它们的顺序是一致的。
 * 
 * @param c 给定集合
 * @throws NullPointerException 
 *         如果给定的集合为空（将null作为参数传递进来）
 */
public ArrayList(Collection<? extends E> c) {
   /*
    * 将集合转化为数组并赋给elementData。
    * c.toArray()返回的实际类型（对象类型）可能不是
    * Object数组。因为Collection的某些实现类（比如：
    * Arrays$ArrayList），是使用泛型数组来存储元素的，
    * 这些类的toArray()方法的返回值保留了实际的类型。
    */
   elementData = c.toArray();
   if ((size = elementData.length) != 0) {
      // elementData实际的类型不是Object数组的时候，
      // 必须将elementData实际的类型变为Object数组。
      if (elementData.getClass() != Object[].class)
         elementData = Arrays.copyOf(elementData, size, Object[].class);
   } else {
      // 使用EMPTY_ELEMENTDATA取代集合转换成的数组，
      // 即将elementData重新赋值为EMPTY_ELEMENTDATA。
      this.elementData = EMPTY_ELEMENTDATA;
   }
} 

程序5 构建包含给定集合所有元素的构造器 

取改元素 

　　在图2中，如果第一个节点的存储地址（首地址）为Loc(a₁)，每一个节点占用的内存为len，由于顺序表使用连续的存储空间来存放元素，那就可以计算出第i个节点的存储地址，如式（1）所示： 

Loc(a_i) = Loc(a₁) + (i-1) * len   （1）

　　根据式（1）得到地址可以找到第i个节点，然后可以对该节点进行操作，比如：获取节点中的元素，修改节点中的元素等。 

　　ArrayList的get (int index)方法就是用来获取节点中的元素，即返回列表中位置（索引）为给定位置（索引）的元素，参见程序6。

/**
 * 返回列表中索引为给定索引的元素。
 * 
 * @param 给定索引
 * @return 列表中索引为给定索引的元素
 * @throws IndexOutOfBoundsException
 *         如果索引小于0或者大于等于size
 */
public E get(int index) {
    // 检查索引是否越界。
    rangeCheck(index);
    // 返回给定索引的元素。
    return elementData(index);
}

程序6 get(int index)方法 

　　ArrayList中的set (int index, E element)方法就是用来修改节点中的元素，即用给定元素替换列表中索引为给定索引的元素，参见程序7。

/**
 * 用给定元素替换列表中索引为给定索引的元素。
 * 
 * @param index 给定索引
 * @param element 给定元素
 * @return 被替换的元素
 * @throws IndexOutOfBoundsException
 *         如果索引小于0或者大于等于size
 */
public E set(int index, E element) {
    // 检查索引是否越界。
    rangeCheck(index);
    // 存储被替换的元素。
    E oldValue = elementData(index);
    // 替换元素。
    elementData[index] = element;
    // 返回被替换的元素。
    return oldValue;
} 

程序7 set(int index, E element)方法

 　　get (int index)方法和set (int index, E element)方法都调用了elementData (index)方法和rangeCheck (index)方法。elementData (int index)方法是以泛型的形式返回elementData数组中索引（下标）为给定索引（下标）的元素，参见程序8；rangeCheck (int index)方法是用来检查下标是否越界，参见程序9，该方法调用了outOfBoundsMsg (index)方法，outOfBoundsMsg (int index)方法用来生成越界信息，参见程序10。

 /**
  * 以泛型的形式返回elementData数组中下标为给定下标的元素。
  */
E elementData(int index) 
    return (E) elementData[index];
}

程序8 elementData(int index)方法 

/**
 * 检查下标是否越界。
 * 该方法没有检查下标为负数的情况，
 * 当下标为负数时，通过该下标访问数组
 * 会抛出数组下标越界异常，
 * 数组下标越界异常也是下标越界异常。
 * 
 * @param 下标
 */
private void rangeCheck(int index) {
    if(index >= size) {
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
} 

程序9 rangeCheck(int index)方法 

/**
 * 生成越界信息。
 * 
 * @param index 下标
 * @return 越界信息
 */
private String outOfBoundsMsg(int index) {
    return "Index: "+index+", Size: "+size;
}

程序10 outOfBoundsMsg(int index)方法 

增删元素 

　　如图3所示，要向一个容量capacity （elementData. length）为n + N，元素个数size为n（这n个元素依次是：a₁、…、a_i-1、a_i、…、a_n）的ArrayList中第i个节点处插入M个元素（这M个元素依次是b₁、…、b_M）。这时至少需要n + M个节点来存储全部元素（原有的n个元素和将要插入的M个元素），将n + M称为最小容量，用minCapacity来表示。向ArrayList中插入元素分为了5步：

 

　　1、判断ArrayList是否是通过无参构造器初始化的并且从来没有进行扩容。如果是的话，就将minCapacity设置为n + M和DEFAULT_ CAPACITY（参见程序1中第 4句代码）中较大的值，参见程序11。这样能够保证通过无参构造器创建的ArrayList对象扩容后的最小容量为DEFAULT_ CAPACITY。  

/**
 * 确保内部容量。
 * 
 * @param minCapacity 最小容量
 */
private void ensureCapacityInternal(int minCapacity) {
    if(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 调用ensureExplicitCapacity(minCapacity)
    // 方法确保列表的容量够用。
    ensureExplicitCapacity(minCapacity);
}

程序11 ensureCapacityInternal(int minCapacity)方法 

　　2、判断是否需要扩容，参见程序12。即判断式（2）是否成立，如果式（2）成立，就需要扩容，进入第3步；如果式（2）不成立，就不需要扩容，直接进入第4步。

/**
 * 确保清晰的容量。
 * 
 * @param minCapacity 最小容量
 */
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    if(minCapacity - elementData.length > 0) {
         grow(minCapacity);
    }
}

程序12 ensureExplicitCapacity(int minCapacity)方法 

　　需要注意的是，式（2）不能写成式（3），即程序12里面第 8句代码中if语句的逻辑表达式不能写成minCapacity > elementData. length，因为前者考虑了溢出问题，后者没有考虑溢出问题。二者的差别通过一个例子说明，比如：minCapacity为Integer. MIN_ VALUE，capacity为Integer. MAX_ VALUE。计算机中使用二进制补码存储数值信息，那Integer. MIN_ VALUE - Integer. MAX_ VALUE等于1，故式（2）是成立的，而式（3）是不成立的。 

minCapacity – elementData.length > 0   （2）

minCapacity > elementData.length   （3）

 　　3、增加ArrayList的容量（扩容），参见程序13。先将ArrayList的容量扩大1.5倍，得到新的容量newCapacity，然后判断newCapacity - minCapacity < 0（不能写成newCapacity < minCapacity）是否成立。如果成立就将newCapacity设置为minCapacity，图3演示就是这种情况。然后创建一个长度为newCapacity的数组，将elementData指向数组中的全部元素依次存储到新数组的前n个元素中，并将该新数组作为ArrayList内部维护的数组，即将elementData指向新数组。

/**
 * 扩容，以确保该数组至少能够存储minCapacity个元素。
 * 
 * @param minCapacity 最小容量
 */
private void grow(int minCapacity) {
    // 旧容量。
    int oldCapacity = elementData.length;
    /*
     * 先扩容一半，即将容量变为原来的1.5倍。
     * >>是移位运算，oldCapacity >> 1等价于
     * oldCapacity / 2,前者效率高于后者。
     */
    int newCapacity = oldCapacity + (oldCapacity >> 2);
    // 如果扩容1.5后的新容量仍然不够用，
    // 继续扩容将新容量设定为最小容量。
    if(newCapacity - minCapacity < 0) {
        newCapacity = minCapacity;
    }
    // 调用hugeCapacity(minCapacity)方法。
    if(newCapacity - MAX_ARRAY_SIZE > 0) {
        newCapacity = hugeCapacity(minCapacity);
    }
    // 创建新数组并复制元素。
    elementData = Arrays.copyOf(elementData, newCapacity);
} 

程序13 grow(int minCapacity)方法 

　　要注意的是，在扩容时得到的新容量newCapacity不能超过数组所允许的最大长度，这是通过调用hugeCapacity (minCapacity)方法来保证的。hugeCapacity (int minCapacity)方法的作用是分情况获取elementData的最大长度，参见程序14。

/**
 * 分情况获取elementData的最大长度。
 * 
 * @param minCapacity 最小容量
 * @return 最大长度
 */
private static int hugeCapacity(int minCapacity) {
    /*
     * 最小容量超过Integer.MAX_VALUE（溢出），
     * 则抛出内存溢出错误。
     * 这里minCapacity超过Integer.MAX_VALUE后
     * 一定得到负数，这是因为minCapacity不会超
     * 出Integer.MAX_VALUE很多，最多超出
     * Integer.MAX_VALUE一倍，故minCapacity不
     * 可能超出Integer.MAX_VALUE后又回到正数。
     */
    if(minCapacity < 0) {
        throw new OutOfMemoryError();
    }
    // 最小容量大于MAX_ARRAY_SIZE，
    // 返回Integer.MAX_VALUE，否则返回MAX_ARRAY_SIZE。
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

程序14 hugeCapacity(int minCapacity)方法 

　　4、移动旧元素，即将elementData数组中下表为i - 1的元素（第i个节点中的元素）及其以后的元素依次向后移动M个位置，即将元素a_i、a_i+1、…、a_n依次存储到第i + M个节点、第i + 1 + M个节点、…、第n + M个节点中。 

　　5、插入新元素，即将要插入的M个元素b₁、…、b_M依次插入到第i个节点、…、第i - 1 + M个节点中。 

　　ArrayList类提供了四个增加元素的方法： 

　　1、add (E e)：追加给定元素到列表的末尾，这时不需要移动旧元素，即不需要上述步骤的第4步，参见程序15。

/**
 * 追加给定元素到列表的末尾。
 * 
 * @param e 追加的元素。
 * @return <tt>true</tt> 
 *         （被{@link Collection#add}规定）
 */
public boolean add(E e) {
    /*
     * 确保列表有足够的容量来存放要追加的元素。
     * 要在列表中追加一个元素，
     * 数组elementData所需要的最小容量为size+1。
     */
    ensureCapacityInternal(size + 1);
    // 将e追加到列表的末尾并对列表元素的个数进行自增。
    elementData[size++] = e;
    return true;
} 

程序15 add(E e)方法 

　　2、addAll (Collection<? extends E> c)：将给定集合的所有元素按照集合的迭代器返回的顺序依次追加到列表的末尾，参见程序16。

/**
 * 将给定集合的所有元素按照集合的迭代器
 * 返回的顺序依次追加到列表的末尾。
 * 执行该方法的时候不允许给定集合发生改变。
 * 如果当前列表不为空集，不能将它自身作为该方法的参数。
 * 
 * @param c 给定集合
 * @return <tt>true</tt> 如果当前列表发生改变
 * @throws IndexOutOfBoundsException
 *         如果下标小于0或者大于size
 * @throws NullPointerException 如果给定集合为空
 */
public boolean addAll(Collection<? extends E> c) {
    // 将给定集合转换为数组
    Object[] a = c.toArray();
    // 获取a的长度（给定集合的元素个数）。
    int numNew = a.length;
    /*
     * 确保列表有足够的容量来存放要追加的元素。
     * 要在列表中追加numNew个元素，
     * 数组elementData所需要的最小容量为size+numNew。
     */
    ensureCapacityInternal(size + numNew);
    // 将数组a的所有元素追加到elementData数组中。
    System.arraycopy(a, 0, elementData, size, numNew);
    // 修改列表中元素的个数。
    size += numNew;
    // numNew != 0 代表集合发生了改变。
    return numNew != 0;
}

程序16 addAll(Collection<? extends E> c)方法 

　　3、add (int index, E element)：在列表中索引为给定索引处插入给定元素，参见程序17。  

/**
 * 在列表中索引为给定索引处插入给定元素。
 * 移动列表中索引为给定索引的元素（如果有的话）
 * 及其以后的元素到它的右边（将它们的下标加1）。
 * 
 * @param index 给定索引。
 * @param element 要插入的元素。
 * @throws IndexOutOfBoundsException
 *         如果下标小于0或者大于size
 */
public void add(int index, E element) {
    //检查索引是否越界。
    rangeCheckForAdd(index);
    // 确保列表有足够的容量来存放要插入的元素。
    ensureCapacityInternal(size + 1);
    // 将列表中索引为给定索引的元素
    // 及其以后的元素依次向后移动一个位置。
    System.arraycopy(elementData, index, elementData, index+1, size-index);
    // 将给定元素插入到指定位置。
    elementData[index] = element;
    // 对元素的个数进行自增。
    size++;
} 

程序17 add(int index, E element)方法 

　　4、addAll (int index, Collection<? extends E> c)：将给定集合的所有元素按照集合的迭代器返回的顺序依次从索引为给定索引处插入到列表中，参见程序18。

/**
 * 将给定集合的所有元素按照集合的迭代器返回的顺序
 * 依次从索引为给定索引处插入到列表中。
 * 移动列表中索引为给定索引的元素（如果有的话）
 * 及其以后的元素到它的右边（增加它们的下标）。
 * 
 * @param index 给定集合的第一个元素插入的位置
 * @param c 给定集合
 * @return <tt>true</tt> 如果当前列表发生改变
 * @throws NullPointerException 如果给定集合为空
 */
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;
    // 如果有要移动的元素，
    // 将这些元素依次向后移动numNew个位置。
    if(numMoved > 0) {
        System.arraycopy(elementData, index, elementData, index + numNew, numMoved); 
    }
    // 将数组a的所有元素插入到elementData数组中。
    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
} 

程序18 addAll(int index, Collection<? extends E> c)方法 

　　add (int index, E element)方法和addAll (int index, Collection<? extends E> c)方法都调用了rangeCheckForAdd (index)方法，该方法是专门为add (int index)和addAll (inde index, Collection<? extends E> c)方法提供的用来检查下标是否越界，参见程序19。该方法也调用了outOfBoundsMsg (index)方法（参见程序10）生成越界信息。

/**
 * 专门为add(int index)和addAll(index index, 
 * Collection<? extends E> c)方法提供的检查下标是否越界。
 * 
 * @param index 下标
 */
private void rangeCheckForAdd(int index) {
    if(index > size || index <0) {
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
} 

程序19 rangeCheckForAdd(int index)方法 

　　如图4所示，要从一个容量capacity为n + N，元素的个数为n（这n个元素依次是：a₁、…、a_i-1、a_i、a_i+1、…、a_n）的ArrayList中删除与给定元素b_i相同的元素分为了2步： 

　　1、在当前列表中查找与给定元素b_i相同的元素。如果在当前列表中找到了与给定元素相同的元素，进入第2步；如果在当前列表中没有找到与给定元素相同的元素，就结束操作，这时没有删除任何元素。 

　　2、将与给定元素b_i相同的元素a_i从列表中删除，可以通过将要删除元素后面的所有元素依次向前移动一个位置来实现。

　　ArrayList类提供了三个删除元素的方法： 

　　1、remove (int index)：删除列表中索引为给定索引的元素，这时不需要查找元素，即不需要上述步骤的第1步，参见程序20。该方法调用了rangeCheck (index)方法（参见程序9）来检查下标是否越界。

/**
 * 删除列表中索引为给定索引的元素。
 * 移动列表中索引为给定索引以后的
 * 所有元素到它的左边（将它们的下标减去1）。
 * 
 * @param index 给定索引
 * @return 被删除的元素
 * @throws IndexOutOfBoundsException
 *         如果下标小于0或者大于等于size
 */
public E remove(int index) {
    // 检查索引是否越界。
    rangeCheck(index);
    // 对modCount自增。
    modCount++;
    // 获取删除的元素。
    E oldValue = elementData(index);
    // 要移动的元素的个数。
    int numMoved = size - index -1;
    // 如果有要移动的元素，将这些元素依次向前移动一个位置。
    if(numMoved > 0)
        System.arraycopy(elementData, index + 1, elementData, index, numMoved);
    // 将列表的最后一个元素赋值为null
    // 并对列表元素的个数进行自减。
    elementData[--size] = null;
    // 返回删除的元素。
    return oldValue;
} 

程序20 remove(int index)方法 

　　2、remove (Object o)：删除列表中与给定元素相同的第一个元素（最多只删除一个元素），如果列表中没有和给定元素相同的元素，就不进行操作，参见程序21。

/**
 * 删除列表中与给定元素相同的第一个元素。
 * 如果列表中没有和给定元素相同的元素，就不进行操作。
 * 
 * @param o 给定元素
 * @return <tt>true</tt> 如果从列表中删除了元素
 */
public boolean remove(Object o) {
    if( o == null) {    // 给定元素为null。
        // 遍历集合的所有元素。
        for(int index=0;index<size;index++) {
            // 如果集合的某一个元素为null，调用
            // fastRemove(index)删除该元素并返回true。
            if(elementData[index] == null) {
                fastRemove(index);
                return true;
            }
        }
    } else {    //给定元素不为null。
        // 遍历集合的所有元素。
        for(int index=0;index<size;index++) {
            // 如果集合的某一个元素和给定元素相同，调用
            // fastRemove(index)删除该元素并返回true。
            if(o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
        }
    }
    // 程序执行到这里，集合中一定不包含给定元素。
    return false;
}

程序21 remove(Object o)方法

 　　在remove (Object o)方法中是调用fastRemove (int index)方法，该方法是专门为remove (Object o)提供的用来快速删除元素，参见程序22。该方法与remove (int index)方法（参见程序20）的区别是：该方法不进行下标越界检查、不返回删除的旧元素。

/**
 * 快速删除元素的方法，不进行下标越界检查，
 * 不返回删除的旧元素。
 */
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index -1;
    if(numMoved > 0)
        System.arraycopy(elementData, index + 1, elementData, index, size – 1 - index);
    elementData[--size] = null;
} 

程序22 fastRemove(int index)方法 

　　3、removeAll (Collection<?> c)：删除列表中所有被给定集合包含的元素，参见程序23。

/**
 * 删除列表中所有被给定集合包含的元素。
 * 
 * @param c 给定集合
 * @return {@code true} 如果当前列表发生改变
 * @throws ClassCastException 
 *         如果当前列表中元素的类型
 *         和给定集合元素的类型不匹配
 * @throws NullPointException 
 *         如果当前列表中包含null
 *         给定集合不允许包含null
 * @see Collection#contains(Object)
 */
public boolean removeAll(Collection<?> c) {
    // 判断c是否为null，如果c为空会抛出空指针异常。
    Objects.requireNonNull(c);
    // 调用batchRemove(c, false)方法
    // 删除被给定集合包含的元素。
    return batchRemove(c, false);
} 

程序23 removeAll(Collection<?> c)方法 

　　在removeAll (Collection<?> c)方法中调用了batchRemove (Collection<?> c, boolean complement)方法，该方法是根据标识（传递的参数complement）删除或保留列表中被给定集合包含的元素，参见程序24。如果complement为false，删除被给定集合包含的元素（保留没有被给定集合包含的元素）；如果complement为true，保留被给定集合包含的元素。

/**
 * 根据给定标识删除或保留列表中被给定集合包含的元素。
 * 
 * @param c 给定集合
 * @param complement 给定标识
 * @return {@code true} 如果当前列表发生改变
 */
private boolean batchRemove(Collection<?> c,boolean complement) {
    // 获取集合内部维护的数组。
    final Object[] elementData = this.elementData;
    // 数组下标变量r，列表新的元素个数w。
    int r = 0, w = 0;
    // 定义变量记录列表是否发生改变。
    boolean modified = false;
    try {
        for(;r<size;r++)
            /*
             * 如果complement为false，
             * 删除被给定集合包含的元素；
             * 如果complement为true，
             * 保留被给定集合包含的元素。
             * 
             * c.contains可能会抛出类型转换异常或空指针异常。
             */
            if(c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
        } finally {
            // r!=size表示执行try里面的代码抛出了异常。
            if(r != size) {
                // 将抛出异常处的元素及其以后的元素保存下来。
                System.arraycopy(elementData, r, elementData, w, size - r);
                w += size -r;
            }
            // w!=size 表示列表发生了改变。
            if(w != size) {
                // 将下标为w到size-1的元素赋值为null。
                for(int i =w;i<size;i++)
                    elementData[i] = null;
                // 修改modCount，删除的元素个数
                // 就是从结构上修改列表的次数。
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
    return modified;
}

程序24 batchRemove(Collection<?> c, boolean complement)方法 

总结

 　　1、ArrayList不是线程安全的，它允许元素的值为null，使用时需要注意。 

　　2、如果事先可以预知数据量的大小，可以通过public ArrayList (int initialCapacity)构造方法来指定集合的大小，以减少扩容次数，提高写入效率。 

　　3、取改元素通过数组下标进行，时间复杂度较低；增删元素会导致数组复制，时间复杂度较高。故在数据量比较大的情况下，取改元素较多，增删元素使用较少，适合使用ArrayList。