List集合之ArrayList（二）通过源码看迭代器实现

柔光的暖阳◎ 2023-10-04 09:17 19阅读 0赞

# 思维导图 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70][]

***(以下源码来自jdk1.8.0\_282)***

# ArrayList迭代器的简介 #

我们知道Collection接口继承了Iterable接口，所以所有的Collection接口的实现类都需要实现Iterable接口中的Iterator<E> iterator()方法。

ArrayList实现了iterator()方法，但是该方法要求返回Iterator实现类对象。此时一般有两个方式获取Iterator实现类对象：

1.定义Iterator接口的匿名内部类

2.定义Iterator接口的实现类

由于匿名内部类只能使用一次，不利于代码复用。（ArrayList有自定义的listIterator()方法，该方法也要返回一个ListIterator迭代器对象）

所以我们为了能够拓展迭代器实现类功能，不选用匿名内部类方式。而选择定义Iterator接口的实现类。

但是，如果将Iterator接口的实现类定义成和ArrayList一样的外部类，则迭代器访问ArrayList的集合元素实现起来比较麻烦。

如果将Iterator接口的实现类定义成ArrayList的成员内部类，则可以直接访问外部类ArrayList的实例成员elementData。

同时为了保证迭代器不暴露集合内部细节，将迭代器实现类定义为ArrayList私有成员内部类。

所以：ArrayList中定义迭代器

1.重写Iterable接口的Iterator<E> iterator()方法

2.将Iterator接口实现类定义为ArrayList集合类的私有实例内部类成员，从而保证迭代器可以直接访问ArrayList的底层数组elementData。

# ArrayList迭代器实现思路 #

## lastRet和cursor概念 ##

在ArrayList的迭代器实现类定义了如下两个变量：

int cursor; //下一个将要被返回的元素的索引

int lastRet = -1； //已经被返回的上一个元素的索引，如果没有上一个被返回的元素，则该值为-1

这两个变量的初始状态：

cursor = 0,lastRet = -1

我们可以将lastRet理解为指针，cursor理解为游标。而一个集合的迭代器开始状态是如下这个样子的：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 1][]

hasNext()就是判断cursor<size，如果是，则说明还有下一个元素，那么就可以执行next()操作

next()操作就是 cursor先向后移动一位，lastRet指向cursor前面一位的位置（注意此处lastRet不是也向后移动一位，而是直接跳到cursor前面一位，可以结合remove()来看），然后返回lastRet指向的元素值

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 2][]

remove()操作：比如现在要删除0x002元素，则需要等lastRet指向0x002时，才可以删除。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 3][]

比如现在又执行了一次next(),所以lastRet指向了0x002。此时迭代器对象调用remove方法，它的底层实现如下

1.ArrayList集合对象调用remove方法删除lastRet索引位置元素。则此时集合对象底层数组改变为

![2021032423112264.png][]

2.cursor移动到lastRet指向位置,lastRet被重置指向-1

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 4][]

综上所诉：指针用于获取集合元素，游标用于探测指针将要指向的下一个元素是否存在

## modCount, fail-fast 快速失败机制 ##

在介绍ArrayList特性时，我们走读add和remove（包括clear）方法时，发现ArrayList集合在插入元素和删除（清空）元素时,都会操作modCount变量

而modCount变量是定义在抽象类AbstractList中的。AbstractList类是作为List接口实现类的父类或超类，是List接口实现类的模板。

该变量被修饰为protected,很明显是给子类使用的。

该变量的介绍是：

The number of times this list has been *structurally modified*.

【list被结构化修改的次数。】

Structural modifications are those that change the size of the list, or otherwise perturb it in such a fashion that iterations in progress may yield incorrect results.

【结构化修改是指：在迭代list过程中，改变了list的size属性值，或者其他方式扰乱了该值，则可能会导致迭代出现不正确的结果。】【注意：list集合什么样的操作会影响list的size属性？size属性是指list集合元素的个数，一般add,remove,clear,retainAll等改变集合元素个数的操作会影响，而set,get,trimToSize,foreach等操作不会】

This field is used by the iterator and list iterator implementation returned by the \{@code iterator\} and \{@code listIterator\} methods.

【 modCount被用在（由iterator()方法和listIterator()返回的）Iterator迭代器和ListIterator迭代器实现类中】【前面说了使list的size改变的操作，都会导致modCount值发生变化。而modCount最终用来干嘛呢？这里说了是用在迭代器中】

If the value of this field changes unexpectedly, the iterator (or list iterator) will throw a \{@code ConcurrentModificationException\} in response to the \{@code next\}, \{@code remove\}, \{@code previous\}, \{@code set\} or \{@code add\} operations.

【如果modCount被意外改变，迭代器将会抛出 ConcurrentModificationException的异常给next,remove,previous,set,add 这些操作。】【这里说，在迭代过程中，如果modCount值变化了，那么迭代器对象调用next，remove,previous,set,add等操作时，都会抛并发修改异常】

This provides *fail-fast* behavior, rather than non-deterministic behavior in the face of concurrent modification during iteration.

【在迭代过程中，如果发现Concurrent modification并发修改情况时，迭代器会提供快速失败机制，而不是不知所措。】【这里吹了一下迭代器的快速失败机制很牛逼】

**Use of this field by subclasses is optional.**

【子类可以选择性的使用AbstractList抽象类中这个字段】【这里说了AbstractList的子类不一定需要使用modCount】

If a subclass wishes to provide fail-fast iterators (and list iterators), then it merely has to increment this field in its \{@code add(int, E)\} and \{@code remove(int)\} methods (and any other methods that it overrides that result in structural modifications to the list).

【如果子类希望提供支持快速失败机制的迭代器，它只需要在add(int, E),remove(int)方法（或者其他它的会导致结构化修改这个列表的方法）中增加modCount。】【这里说，如果AbstractList的子类使用modCount的话，每次导致list结构化修改的操作需要增加modCount】

A single call to \{@code add(int, E)\} or \{@code remove(int)\} must add no more than one to this field, or the iterators (and list iterators) will throw bogus \{@code ConcurrentModificationExceptions\}.

【只调用一次add或者remove，必须增加modCount，但是增加的值不能超过1。否则迭代器会抛出ConcurrentModificationException。】【这里说了每次结构化修改操作发生后，modCount最好只加1，如果加2，加3的话，迭代器就会抛出并发修改异常】

If an implementation does not wish to provide fail-fast iterators, this field may be ignored.

【如果实现类不希望提供支持快速失败机制的迭代器，则可以忽略modCount字段】【这里说明了modCount就是专门给迭代器用来判断是否快速失败的，如果不需要快速失败的话，可以忽略modCount】

/**
 * The number of times this list has been structurally modified.
 * Structural modifications are those that change the size of the
 * list, or otherwise perturb it in such a fashion that iterations in
 * progress may yield incorrect results.
 *
 * This field is used by the iterator and list iterator implementation
 * returned by the {@code iterator} and {@code listIterator} methods.
 * If the value of this field changes unexpectedly, the iterator (or list
 * iterator) will throw a {@code ConcurrentModificationException} in
 * response to the {@code next}, {@code remove}, {@code previous},
 * {@code set} or {@code add} operations. This provides
 * fail-fast behavior, rather than non-deterministic behavior in
 * the face of concurrent modification during iteration.
 *
 * Use of this field by subclasses is optional. If a subclass
 * wishes to provide fail-fast iterators (and list iterators), then it
 * merely has to increment this field in its {@code add(int, E)} and
 * {@code remove(int)} methods (and any other methods that it overrides
 * that result in structural modifications to the list). A single call to
 * {@code add(int, E)} or {@code remove(int)} must add no more than
 * one to this field, or the iterators (and list iterators) will throw
 * bogus {@code ConcurrentModificationExceptions}. If an implementation
 * does not wish to provide fail-fast iterators, this field may be
 * ignored.
 */
 protected transient int modCount = 0;

# ArrayList迭代器源码分析 #

## public Iterator<E> iterator() ##

/**
 * Returns an iterator over the elements in this list in proper sequence.
 *
 * The returned iterator is <a href="#fail-fast">fail-fast</a>.
 *
 * @return an iterator over the elements in this list in proper sequence
 */
 public Iterator<E> iterator() {
 return new Itr();// Itr类是Iterator接口的实现类，同时是定义在ArrayList中的私有成员内部类。
 }
 
 /**
 * An optimized version of AbstractList.Itr
 */
 private class Itr implements Iterator<E> {
 int cursor; // index of next element to return // 游标,初始值cursor=0，即游标处在集合第一个元素上，游标用于探测下一个元素
 int lastRet = -1; // index of last element returned; -1 if no such // 指针，初始值lastRet=-1,即指针初始时不指向集合元素，指针用于获取集合元素
 int expectedModCount = modCount;// modCount是指集合被结构化修改的次数。这里在迭代器对象被创建时备份了当前集合的modCount值到exceptedModCount。这是为了保证迭代器迭代过程中，实时监测集合的modCount值是否被改变了，即exceptedModCount！= modCount，如果是，则集合元素已经被结构化修改，迭代器就会抛出并发修改异常。
 
 Itr() {} // 只提供了无参构造器
 
 public boolean hasNext() {// hasNext方法用于判断迭代器将要迭代的下一个元素是否存在
 return cursor != size;// 由于集合元素是0~size-1的，而迭代器的迭代又是顺序执行的，即只会按0，1，2，3,...,size-1的迭代顺序迭代，所以当游标cursor位置最多移动到size位，然后返回false，表示没有下一个元素了。
 }
 
 @SuppressWarnings("unchecked")
 public E next() {// next方法用于获取下一个元素，但是内部操作比较复杂
 checkForComodification();// 执行next操作前，检查集合没有被结构化修改，即保证exceptedModCount == modCount成立，若成立则继续执行，否则抛出并发修改异常
 int i = cursor;
 if (i >= size) // 如果游标已经在集合size位置，或者超出size位置
 throw new NoSuchElementException();// 则next方法必然无法获得下一个元素，即无下一个元素存在
 Object[] elementData = ArrayList.this.elementData;
 if (i >= elementData.length) // 如果游标位置已经超出了集合容量（这种情况应该是cursor已经在size位置，但是此时对集合进行了trimToSize操作，则集合底层数组容量就是size，就会出现i>=elementData.length，但是此时游标cursor其实已经超出了elementData数组的索引范围，此处java视为并发修改异常）
 throw new ConcurrentModificationException();
 cursor = i + 1;// 如果上面都没有问题的话，则游标先移动到下一位
 return (E) elementData[lastRet = i];// 然后指针lastRet指向游标当前所在位置的前一位，并获取该位置的元素，返回。
 }
 
 public void remove() {// remove方法用于删除迭代器正在迭代的元素，内部实现比较复杂
 if (lastRet < 0) // 首先迭代器正在迭代的元素，就是指针lastRet指向的元素，当迭代器初始化时，此时指针不指向集合中任何元素，即lastRet是-1时，就会由于没有迭代的元素，所以不能remove空的元素，就会报错非法状态异常
 throw new IllegalStateException();
 checkForComodification();// remove操作前要检查集合是否被结构化修改
 
 try {
 ArrayList.this.remove(lastRet);// 先利用集合对象删除lastRet指向的元素，注意此时集合的modCount值会被改变
 cursor = lastRet; // 由于指针lastRet指向的元素已经被删除了，所以理论上指针当前无指向元素，而由于cursor指向的元素后移了一位，所以cursor指向了lastRet原本的位置
 lastRet = -1; // 由于lastRet指向的元素已经被删除了，所以lastRet无指向元素，所以将其重置位-1
 expectedModCount = modCount;// 由于之前集合的remove操作已经改变了集合的modCount值，所以将集合最新的modCount值给了excepetedModCount
 } catch (IndexOutOfBoundsException ex) {
 throw new ConcurrentModificationException();// try里面能抛出异常的只有集合的remove操作，如果该步抛异常了，说明要remove的元素出问题了，则报错并发修改异常
 }
 }
 
 @Override
 @SuppressWarnings("unchecked")
 public void forEachRemaining(Consumer<? super E> consumer) {// foreachRemaining方法用于遍历集合每个元素给consumer处理，外部调用此方法，需要提供Consumer接口的实现类对象，由于Consumer是函数式接口，所以建议Lambda表达式，直接重写accept方法即可，accepet的方法形参就是foreachRemaining方法遍历的每个集合元素
 Objects.requireNonNull(consumer);// 首先保证consumer非null，否则后面调用consumer的accept操作会报错空指针
 final int size = ArrayList.this.size;// 获取集合元素个数
 int i = cursor;// 
 if (i >= size) {// 如果游标指向已经超出的集合元素的范围，则方法结束，即顺序迭代已经迭代到了最后一个元素
 return;
 }
 final Object[] elementData = ArrayList.this.elementData;
 if (i >= elementData.length) {//同next方法中该逻辑解释
 throw new ConcurrentModificationException();
 }
 while (i != size && modCount == expectedModCount) {// 只要没有遍历结束且集合没有被结构化修改，就一直执行
 consumer.accept((E) elementData[i++]);// 利用consumer的accept方法处理集合元素
 }
 // update once at end of iteration to reduce heap write traffic
 cursor = i;// 当上面遍历结束后，i已经等于size了，即游标指向了size位置
 lastRet = i - 1;//而指针此时指向游标前一位，即集合最后一个元素的位置
 checkForComodification();// 在foreachRemaining结束前，判断有无并发修改异常，若没有，则正常结束方法，若有则抛出异常，但是此时集合元素已经被遍历处理完成。
 }
 
 final void checkForComodification() {
 if (modCount != expectedModCount)
 throw new ConcurrentModificationException();
 }
 }

源码走读分析加注释在上面代码每行后面。但是过于抽象，下面通过画图的方式，演示Itr类的hasNext,next,remove,foreachRemaining方法执行过程

### 下图是关于hasNext()和next() ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 5][]

### 下图是关于remove() ###

## ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 6][] ##

### 下图是关于foreachRemaining(Consumer consumer) ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 7][]

## public ListIterator<E> listIterator(int index) ##

/**
 * Returns a list iterator over the elements in this list (in proper
 * sequence), starting at the specified position in the list.
 * The specified index indicates the first element that would be
 * returned by an initial call to {@link ListIterator#next next}.
 * An initial call to {@link ListIterator#previous previous} would
 * return the element with the specified index minus one.
 *
 * The returned list iterator is <a href="#fail-fast">fail-fast</a>.
 *
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
 public ListIterator<E> listIterator(int index) {
 if (index < 0 || index > size)
 throw new IndexOutOfBoundsException("Index: "+index);
 return new ListItr(index);
 }

## public ListIterator<E> listIterator() ##

/**
 * Returns a list iterator over the elements in this list (in proper
 * sequence).
 *
 * The returned list iterator is <a href="#fail-fast">fail-fast</a>.
 *
 * @see #listIterator(int)
 */
 public ListIterator<E> listIterator() {
 return new ListItr(0);
 }

从上面两个方法定义可以看出

listIterator()返回的是new ListItr(0)

listIterator(int index)返回的是 new ListItr(index)

说明ListItr实现类必须传入一个ArrayList对象某个元素的索引值。至于该索引值的作用，需要看ListItr类如何使用它。

### ListItr实现类定义 ###

/**
 * An optimized version of AbstractList.ListItr
 */
 private class ListItr extends Itr implements ListIterator<E> {
 ListItr(int index) {
 super();
 cursor = index;
 }
 
 public boolean hasPrevious() {
 return cursor != 0;// 可以和hasNext对比
 }
 
 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();
 }
 }
 }

从ListItr类定义来看，index会被赋值给cursor。

对比之前的Itr类，Itr类的cursor初始是0，后续随着next()方法或foreachRemainingf方法的调用而改变，即没有其他方式可以cursor值。

而ListItr中，将cursor的初始值交给了外部调用者。即调用者希望迭代器的游标（下一个元素）指向哪里就指向哪里。

ListItr中的

nextIndex()方法就是获取cursor值

previousIndex()方法就是获取cursor-1值

hasPrevious()方法和hasNext()相反，hasNext()是保证游标指向不超出集合元素尾部索引，hasPrevious()是保证游标指向不超出集合元素头部索引

previous()和next()实现刚好相反，next()是将cursor,lastRet不断向后移动，previous()是将cursor,lastRet不断向前移动

set(E e)是修改lastRet指向的元素为e

add(E e)是在cursor位置添加新的元素，且将lastRet重置为-1

### ListIterator接口定义 ###

package java.util;
 
 public interface ListIterator<E> extends Iterator<E> {
 
 boolean hasNext();
 
 E next();
 
 boolean hasPrevious();
 
 E previous();
 
 int nextIndex();
 
 int previousIndex();
 
 void remove();
 
 void set(E e);
 
 void add(E e);
 }

可以发现ListIterator接口继承了Iterator接口，即ListIterator接口也有hasNext(),next(),remove(),foreachRemaining(Consumer consumer)方法。
    
    同时ListIterator还额外增加了hasPrevious(),previous(),nextIndex(),perviousIndex(),set(E e),add(E e)
    
    其实新增的方法依据ArrayList特性定制的。
    
    由于ArrayList的底层是数组，所以ArrayList的元素可以支持随机访问，而Iterator中只支持hasNext(),next()访问下一个元素，不支持访问上一个元素。
    
    所以在ListIterator中，根据ArrayList元素访问的随机性特点，增加了hasPrevious(),previous()访问上一个元素的操作。
    
     另外ArrayList也支持修改任意索引位置的元素，以及增加一个元素，获取元素索引等操作。即定制了nextIndex(),perviousIndex(),set(E e),add(E e)等方法。

### 图示示hasPrevious(),previous(),add(E e),set(E e)的过程 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 8][]

# 思考题 #

## 0、导致ArrayList集合结构化修改的操作有哪些？ ##

集合结构化修改，即改变了集合的modCount值。
    
    ArrayList中
    
    add(E e)
    add(int index, E e)
    addAll(Collection c)
    addAll(int index, Collection c)
    
    remove(E e)
    remove(int index)
    removeAll(Collecion c)
    removeIf(Predicate p)
    
    retainAll(Collection c)
    
    trimToSize()
    ensureCapacity(int minCapacity)
    
    replaceAll(UnaryOperator uo)
    sort(Comparator cn)
    
    
    总结上面这些操作：
    增加，删除元素 这些改变了集合size的操作（包括所有的add,remove以及retainAll）
    改变集合容量的操作 （trimToSize，ensureCapacity）
    超过一个的改变集合元素（replaceAll，sort）
    
    这些将集合改的面目全非的操作都可以看成结构化修改

##  ##

## 1、请看下面代码运行结果 ##

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.ListIterator;
    
    public class ArrayListTest {
        public static void main(String[] args) {
            ArrayList arrayList = new ArrayList();
            Collections.addAll(arrayList,1,2,3,4,5,6,7);
    
            ListIterator listIterator = arrayList.listIterator(2);
            Object previous = listIterator.previous();
            Object next = listIterator.next();
            System.out.println(previous);
            System.out.println(next);
        }
    }

运行结果输出
    2
    2
    
    
    解析：
    我们知道迭代器previous()和next()操作返回的元素都是取自lastRet指向的元素。
    
    
    listIterator迭代器初始化时：lastRet=-1,cursor=2
    
    之后执行了previous()操作：cursor=1,lastRet=1,该步返回的元素是elementData[1]
    再执行next()操作：cursor=2,lastRet=1,该步返回的元素也是elementData[1]
    
    本题的关键在于知道previous()操作后，lastRet和cursor指向同一个元素。

## 2、请看下面代码运行结果 ##

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.ListIterator;
    
    public class ArrayListTest {
        public static void main(String[] args) {
            ArrayList arrayList = new ArrayList();
            Collections.addAll(arrayList,1,2,3,4,5,6,7);
    
            ListIterator listIterator = arrayList.listIterator(2);
            listIterator.remove();
            listIterator.add(2);
        }
    }

抛出异常IllegalStateException
    
    原因是 listIterator迭代器初始化时lastRet是-1
    
    而remove()操作就是删除lastRet位置的元素，而-1不知向任何元素，所以要删除的元素的状态不对。

## 3、请看下面代码运行结果 ##

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.ListIterator;
    
    public class ArrayListTest {
        public static void main(String[] args) {
            ArrayList arrayList = new ArrayList();
            Collections.addAll(arrayList,1,2,3,4,5,6,7);
    
            ListIterator listIterator = arrayList.listIterator(2);
            listIterator.next();
            listIterator.remove();
            listIterator.add(3);
            listIterator.remove();
        }
    }

抛出IllegalStateException
    
    listIterator.add(3);操作后，lastRet被重置为-1，所以不能再执行remove()操作

## 4、请看下面代码运行结果 ##

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.ListIterator;
    
    public class ArrayListTest {
        public static void main(String[] args) {
            ArrayList arrayList = new ArrayList();
            Collections.addAll(arrayList,1,2,3,4,5,6,7);
    
            ListIterator listIterator = arrayList.listIterator(2);
            listIterator.add(3.5);
            System.out.println(listIterator.nextIndex());
            System.out.println(arrayList);
        }
    }

nextIndex()获取的是迭代器cursor的位置
    
    迭代器初始化时：cursor=2
    
    add(3.5)：
    
    add操作是在cursor位置插入元素，所以即在索引2处插入了3.5，而cursor指向的元素，被挤到到了索引3的位置
    
    
    所以最终输出
    
    3
    [1,2,3.5,3,4,5,6,7]

## 5、请看下面代码运行结果 ##

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.ListIterator;
    
    public class ArrayListTest {
        public static void main(String[] args) {
            ArrayList arrayList = new ArrayList();
            Collections.addAll(arrayList,1,2,3,4,5,6,7);
    
            ListIterator listIterator = arrayList.listIterator(2);
            listIterator.next();
            listIterator.remove();
            listIterator.add(3);
            System.out.println(arrayList);
        }
    }

listIterator初始化时，lastRet=-1,cursor=2
    next()操作后，cursor=3,lastRet=2
    remove()操作后，删除了lastRet的元素，cursor指向元素前移一位，cursor=2,lastRet被重置为-1
    [1,2,4,5,6,7]
    
    
    add(3)操作后，在cursor位置插入元素，cursor指向元素后移一位，cursor=3,lastRet被重置为-1
    [1,2,3,4,5,6,7]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2021032913114355.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2021032423011687.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210324230259559.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210324230615688.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[2021032423112264.png]: https://img-blog.csdnimg.cn/2021032423112264.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210324231340888.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210325163034886.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210325164135759.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210325170137198.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20210326105634751.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70