2，ArrayList

一，ArrayList简介

1，ArrayList 是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。

2，ArrayList 继承了AbstractList，实现了List。实现了 List 的一些位置相关操作(比如 get,set,add,remove)。

3，ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。

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

5，ArrayList 实现Serializable接口，说明ArrayList支持序列化。

6，ArrayList不是线程安全的！在多线程中建议选择Vector或者CopyOnWriteArrayList。

二，数据结构

ArrayList的数据结构如下：

底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。对ArrayList类的实例的所有的操作底层都是基于数组的。

三，ArrayList源码

1，ArrayList结构

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 = {};
 
    /**
     * Object[]类型的数组，保存了添加到ArrayList中的元素。
     * ArrayList的容量是该Object[]类型数组的长度。
     * 当第一个元素被添加时，任何空的ArrayList中的elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA将会被
     * 扩充到DEFAULT_CAPACITY。
     */
    transient Object[] elementData; 
 
    // ArrayList的实际大小（指其所含的元素个数）
    private int size;
 
    省略......
}

1.1，elementData对象

elementData是Object[] 类型的数组，它保存了添加到ArrayList中的元素。

我们通过构造函数 ArrayList(int initialCapacity)来创建时，它的初始容量为initialCapacity。如果通过不含参数的构造函数ArrayList()来创建 ArrayList，则elementData的容量默认是10。

elementData是个动态数组大小会根据ArrayList容量的增长而动态的增长。

1.2，size

动态数组的实际大小。

2，构造函数

ArrayList提供了三种方式的构造器，如下

构造器一：

/**
 * 构造一个指定初始容量的空列表
 * @param  initialCapacity  ArrayList的初始容量
 * @throws 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);
    }
}

构造器二：

/**
 * 无参构造函数，设置元素数组为空。
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

构造器三：

/**
 * 当传递的参数为集合类型时，会把集合类型转化为数组类型，并赋值给elementData
 * @param c 包含用于去构造ArrayList的元素的collection
 * @throws NullPointerException 指定的collection为空，则抛出异常
 */
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        if (elementData.getClass() != Object[].class)
            //返回一个 Object[].class类型的，大小为size，元素为elementData[0,...,size-1]
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 用空数组替换
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

3，部分函数

3.1，add()函数

public boolean add(E e) {
    ensureCapacityInternal(size + 1); 
    elementData[size++] = e;
    return true;
}
// 将e添加到ArrayList的指定位置
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++;
}

在add函数发现其调用了函数ensureCapacityInternal，ensureCapacityInternal的具体函数如下：

private void ensureCapacityInternal(int minCapacity) {
    //判断元素数组是否为空数组
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { 
        // 取较大值
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

在ensureCapacityInternal函数发现其调用了函数ensureExplicitCapacity，ensureExplicitCapacity的具体函数如下：

private void ensureExplicitCapacity(int minCapacity) {
    //修改次数+1
    modCount++;
 
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

在ensureExplicitCapacity函数发现其调用了函数grow，grow函数才会对数组进行扩容，grow函数的具体函数如下：

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;// 旧容量
    int newCapacity = oldCapacity + (oldCapacity >> 1);// 新容量为旧容量的1.5倍
    // 判断新容量小于参数指定容量，修改新容量
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 判断新容量大于最大容量
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);// 指定新容量，特殊情况下（新扩展数组大小已经达到了最大值）则只取最大值。
    // 拷贝扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}

3.2，remove函数

public E remove(int index) {
    // 检查索引是否合法
    rangeCheck(index);
    // 修改次数+1
    modCount++;
    E oldValue = elementData(index);
    // 需要移动的元素的个数
    int numMoved = size - index - 1;
    if (numMoved > 0)
        //复制数组
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 赋值为空，有利于进行GC（垃圾回收），避免内存泄漏（否则实际上数组中依然有该引用，gc无法进行垃圾回收）
    elementData[--size] = null; 
    // 返回旧值
    return oldValue;
}
//该方法能够擦除list中值为null的元素！
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) {
    // 修改次数+1
    modCount++;
    // 需要移动的元素的个数
    int numMoved = size - index - 1;
    if (numMoved > 0)
        //复制数组
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 赋值为空，有利于进行GC（垃圾回收），避免内存泄漏（否则实际上数组中依然有该引用，gc无法进行垃圾回收）
    elementData[--size] = null; 
}

说明：

remove(int index)	该函数用户移除指定下标的元素，此时会把指定下标到数组末尾的元素向前移动一个单位，并且会把数组最后一个元素设置为null，这样是为了方便之后将整个数组不被使用时，会被GC（垃圾回收）。
remove(Object o)	该函数能够擦除list中值为null的元素！ 当然当传进来的元素为null时，循环数组，根据下标判断元素是否为null，如果是null时，调用fastRemove方法。 当然当传进来的元素不为null时，循环数组，调用的是元素的equals方法，如果相等时，能调用fastRemove方法。

3.3，removeAll()，retainAll()函数

//删除指定集合的元素
public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);//检查参数是否为null
    return batchRemove(c, false);
}
//仅保留指定集合的元素
public boolean retainAll(Collection<?> c) {
    Objects.requireNonNull(c);//检查参数是否为null
    return batchRemove(c, true);
}

3.4，batchRemove()函数

/**
 * 根据条件删除/保留指定的元素列表。
 * @param complement true时从数组保留指定集合中元素的值，为false时从数组删除指定集合中元素的值。
 * @return 数组中重复的元素都会被删除(而不是仅删除一次或几次)，有任何删除操作都会返回true
 */
private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        //遍历数组，并检查这个集合是否包含对应的值，移动要保留的值到数组前面，w最后值为要保留的元素的数量
        //简单点：若保留，就将相同元素移动到前段；若删除，就将不同元素移动到前段
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    }finally {//确保异常抛出前的部分可以完成期望的操作，而未被遍历的部分会被接到后面
        //r!=size表示可能出错了：c.contains(elementData[r])抛出异常
        if (r != size) {
            System.arraycopy(elementData, r,elementData, w,size - r);
            w += size - r;
        }
        //如果w==size：表示全部元素都保留了，所以也就没有删除操作发生，所以会返回false；反之，返回true，并更改数组
        //而w!=size的时候，即使try块抛出异常，也能正确处理异常抛出前的操作，因为w始终为要保留的前段部分的长度，数组也不会因此乱序
        if (w != size) {
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;//改变的次数
            size = w;   //新的大小为保留的元素的个数
            modified = true;
        }
    }
    return modified;
}

四，ArrayList遍历方式

ArrayList支持3种遍历方式。

1，迭代器遍历

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

2，随机访问，通过索引值去遍历。

由于ArrayList实现了RandomAccess接口，它支持通过索引值去随机访问元素。

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

3，for循环遍历

for (String string : list) {
    System.out.println(string);
}

下面通过一个实例，比较这3种方式的效率，代码如下：

public class Test {
    static long startTime = 0;
    static long endTime = 0;
    
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 100000; i++) {
            list.add(i + "");
        }
        Test.loopList_Indexes(list);
        Test.loopList_Iterator(list);
        Test.loopList_For(list);
    }
    //随机访问，通过索引值去遍历。
    public static void loopList_Indexes(List<String> list){
        startTime = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            list.get(i);
        }
        endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println("随机访问，通过索引值去遍历(loopList_Indexes)：" + interval + " ms");
    }
    //通过迭代器遍历
    public static void loopList_Iterator(List<String> list){
        startTime = System.currentTimeMillis();
        for (Iterator<String> iter = list.iterator(); iter.hasNext();) {
            iter.next();
        }
        endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println("通过迭代器遍历(loopList_Iterator)：" + interval + " ms");
    }
    
    //通过for循环遍历
    public static void loopList_For(List<String> list){
        startTime = System.currentTimeMillis();
        String tString;
        for (String string : list) {
            tString = string;
        }
        endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println("通过for循环遍历(loopList_For)：" + interval + " ms");
    }
}

运行结果：

由此可见，遍历ArrayList时，使用随机访问(即，通过索引序号访问)效率最高，而使用迭代器的效率最低！

五，常用函数

//因为容量常常会大于实际元素的数量。内存紧张时，可以调用该方法删除预留的位置，调整容量为元素实际数量。
//如果确定不会再有元素添加进来时也可以调用该方法来节约空间
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
    }
}
//使用指定参数设置数组容量
public void ensureCapacity(int minCapacity) {
    //如果数组为空，容量预取0，否则去默认值(10)
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)? 0: 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++;
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
//数组的最大容量，可能会导致内存溢出(VM内存限制)
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//增加容量，以确保它可以至少持有由参数指定的元素的数目
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    //预设容量增加一半
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //取与参数中的较大值
    if (newCapacity - minCapacity < 0)//即newCapacity<minCapacity
        newCapacity = minCapacity;
    //若预设值大于默认的最大值检查是否溢出
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}
//检查是否溢出，若没有溢出，返回最大整数值(java中的int为4字节，所以最大为0x7fffffff)或默认最大值
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) //溢出
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
//返回数组大小
public int size() {
    return size;
}
//是否为空
public boolean isEmpty() {
    return size == 0;
}
//是否包含一个数 返回bool
public boolean contains(Object o) {
    return indexOf(o) >= 0;
}
//返回一个值在数组首次出现的位置，会根据是否为null使用不同方式判断。不存在就返回-1。时间复杂度为O(N)
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;
}
//返回一个值在数组最后一次出现的位置，不存在就返回-1。时间复杂度为O(N)
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;
}
//返回副本，元素本身没有被复制，复制过程数组发生改变会抛出异常
public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        throw new InternalError(e);
    }
}
//转换为Object数组，使用Arrays.copyOf()方法
public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}
//返回一个数组，使用运行时确定类型，该数组包含在这个列表中的所有元素（从第一到最后一个元素）
//返回的数组容量由参数和本数组中较大值确定
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
    if (a.length < size)
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}
//返回指定位置的值，因为是数组，所以速度特别快
@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) {
    rangeCheck(index);
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}
//添加一个值，首先会确保容量
public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}
//指定位置添加一个值，会检查添加的位置和容量
public void add(int index, E element) {
    rangeCheckForAdd(index);
    ensureCapacityInternal(size + 1);
    //public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
    //src:源数组； srcPos:源数组要复制的起始位置； dest:目的数组； destPos:目的数组放置的起始位置； length:复制的长度
    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; //便于垃圾回收期回收
    return oldValue;
}
//删除指定元素首次出现的位置
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
}
//清空数组，把每一个值设为null,方便垃圾回收(不同于reset，数组默认大小有改变的话不会重置)
public void clear() {
    modCount++;
    for (int i = 0; i < size; i++) elementData[i] = null;
    size = 0;
}
//添加一个集合的元素到末端，若要添加的集合为空返回false
public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew); 
    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);  //确保容量
    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;
}
//删除指定范围元素。参数为开始删的位置和结束位置
protected void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = size - toIndex;  //后段保留的长度
    System.arraycopy(elementData, toIndex, elementData, fromIndex,numMoved);
    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));
}
//检查是否溢出
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//抛出的异常的详情
private String outOfBoundsMsg(int index) {
    return "Index: "+index+", Size: "+size;
}
//删除指定集合的元素
public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);//检查参数是否为null
    return batchRemove(c, false);
}
//仅保留指定集合的元素
public boolean retainAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, true);
}
/**
 * 源码解读 BY http://anxpp.com/
 * @param complement true时从数组保留指定集合中元素的值，为false时从数组删除指定集合中元素的值。
 * @return 数组中重复的元素都会被删除(而不是仅删除一次或几次)，有任何删除操作都会返回true
 */
private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        //遍历数组，并检查这个集合是否包含对应的值，移动要保留的值到数组前面，w最后值为要保留的元素的数量
        //简单点：若保留，就将相同元素移动到前段；若删除，就将不同元素移动到前段
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    }finally {//确保异常抛出前的部分可以完成期望的操作，而未被遍历的部分会被接到后面
        //r!=size表示可能出错了：c.contains(elementData[r])抛出异常
        if (r != size) {
            System.arraycopy(elementData, r,elementData, w,size - r);
            w += size - r;
        }
        //如果w==size：表示全部元素都保留了，所以也就没有删除操作发生，所以会返回false；反之，返回true，并更改数组
        //而w!=size的时候，即使try块抛出异常，也能正确处理异常抛出前的操作，因为w始终为要保留的前段部分的长度，数组也不会因此乱序
        if (w != size) {
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;//改变的次数
            size = w;   //新的大小为保留的元素的个数
            modified = true;
        }
    }
    return modified;
}
//保存数组实例的状态到一个流（即它序列化）。写入过程数组被更改会抛出异常
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
    int expectedModCount = modCount;
    s.defaultWriteObject(); //执行默认的反序列化/序列化过程。将当前类的非静态和非瞬态字段写入此流
    // 写入大小
    s.writeInt(size);
    // 按顺序写入所有元素
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}
//上面是写，这个就是读了。
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;
    // 执行默认的序列化/反序列化过程
    s.defaultReadObject();
    // 读入数组长度
    s.readInt();
    if (size > 0) {
        ensureCapacityInternal(size);
        Object[] a = elementData;
        //读入所有元素
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}
//返回ListIterator，开始位置为指定参数
public ListIterator<E> listIterator(int index) {
    if (index < 0 || index > size)
        throw new IndexOutOfBoundsException("Index: "+index);
    return new ListItr(index);
}
//返回ListIterator，开始位置为0
public ListIterator<E> listIterator() {
    return new ListItr(0);
}
//返回普通迭代器
public Iterator<E> iterator() {
    return new Itr();
}
//通用的迭代器实现
private class Itr implements Iterator<E> {
    int cursor;       //游标，下一个元素的索引，默认初始化为0
    int lastRet = -1; //上次访问的元素的位置
    int expectedModCount = modCount;//迭代过程不运行修改数组，否则就抛出异常
    //是否还有下一个
    public boolean hasNext() {
        return cursor != size;
    }
    //下一个元素
    @SuppressWarnings("unchecked")
    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];    //设置访问的位置并返回这个值
    }
    //删除元素
    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();//检查数组是否被修改
        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
    @Override
    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
        Objects.requireNonNull(consumer);
        final int size = ArrayList.this.size;
        int i = cursor;
        if (i >= size) {
            return;
        }
        final Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }
    //检查数组是否被修改
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}
//ListIterator迭代器实现
private class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {
        super();
        cursor = index;
    }
    public boolean hasPrevious() {
        return cursor != 0;
    }
    public int nextIndex() {
        return cursor;
    }
    public int previousIndex() {
        return cursor - 1;
    }
    @SuppressWarnings("unchecked")
    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];
    }
    public void set(E e) {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();
        try {
            ArrayList.this.set(lastRet, e);
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
    public void 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();
        }
    }
}
//返回指定范围的子数组
public List<E> subList(int fromIndex, int toIndex) {
    subListRangeCheck(fromIndex, toIndex, size);
    return new SubList(this, 0, fromIndex, toIndex);
}