if (elementData[i]==null)

return i;

} else {

// 本质就是循环 equals 比对

for (int i = 0; i < size; i++)

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 {

// 逆向循环 equals 比对

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

// 实现数组的复制，参数为被复制者的参数

v.elementData = Arrays.copyOf(elementData, size);

v.modCount = 0;

return v;

} catch (CloneNotSupportedException e) {

// this shouldn’t happen, since we are Cloneable

throw new InternalError(e);

}

}

/**

• 返回一个包含此列表中所有元素的数组（理解为将集合转为数组即可）

*/

public Object[] toArray() {

return Arrays.copyOf(elementData, size);

}

/**

• 将list转化为你所需要类型的数组，然后返回

*/

@SuppressWarnings(“unchecked”)

public T[] toArray(T[] a) {

if (a.length < size)

// Make a new array of a’s runtime type, but my contents:

return (T[]) Arrays.copyOf(elementData, size, a.getClass());

// 复制用法，下面专题会讲解此内容

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) {

// index 范围检查

rangeCheck(index);

return elementData(index);

}

/**

• 用指定的元素替换此列表中指定位置的元素。

*/

public E set(int index, E element) {

// index 范围检查

rangeCheck(index);

// 根据 index 找到想替换的旧元素

E oldValue = elementData(index);

// 替换元素

elementData[index] = element;

return oldValue;

}

/**

• 将指定的元素追加到此列表的末尾。

*/

public boolean add(E e) {

// 确认 list 容量，尝试容量加 1，看看有无必要扩容

ensureCapacityInternal(size + 1); // Increments modCount!!

// 赋值

elementData[size++] = e;

return true;

}

/**

• 在此列表中的指定位置插入指定的元素

• 再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。

*/

public void add(int index, E element) {

// 调用 rangeCheckForAdd 对 index 进行范围检查

rangeCheckForAdd(index);

// 保证容量足够

ensureCapacityInternal(size + 1); // Increments modCount!!

// 自己复制自己，然后达到 index 之后全部元素向后挪一位的效果

System.arraycopy(elementData, index, elementData, index + 1,

size - index);

// 然后将 index 赋值为指定的元素

elementData[index] = element;

size++;

}

/**

• 移除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。

*/

public E remove(int index) {

// 调用 rangeCheckForAdd 对 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;

}

/**

• 从集合中移除第一次出现的指定元素

*/

public boolean remove(Object o) {

if (o == null) {

for (int index = 0; index < size; index++)

if (elementData[index] == null) {

fastRemove(index);

return true;

}

} else {

// 也很简单，就是一个循环 equals 判断，然后移除

for (int index = 0; index < size; index++)

if (o.equals(elementData[index])) {

fastRemove(index);

return true;

}

}

return false;

}

/*

• 跳过范围检查的删除方式，与remove(Object o)相同

*/

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

// clear to let GC do its work

for (int i = 0; i < size; i++)

// 元素全部设为 null

elementData[i] = null;

// 长度设为 0

size = 0;

}

/**

• 按指定集合的Iterator返回的顺序

• 将指定集合中的所有元素追加到此列表的末尾。

*/

public boolean addAll(Collection<? extends E> c) {

// 转为数组

Object[] a = c.toArray();

// 拿到待添加指定数组的长度

int numNew = a.length;

// 确认 list 容量，尝试容量加上 numNew，看看有无必要扩容

ensureCapacityInternal(size + numNew); // Increments modCount

// 利用 arraycopy 指定数组a的元素追加到当前数组 elementData 后

System.arraycopy(a, 0, elementData, size, numNew);

size += numNew;

return numNew != 0;

}

/**

• 按指定集合的Iterator返回的顺序

• 将指定集合中的所有元素添加到此列表中，从指定位置开始

*/

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)

// 实现元素指定位置的插入，本质还是 arraycopy 自身

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使用

*/

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

return batchRemove(c, false);

}

/**

• 仅保留此列表中包含在指定集合中的元素。即删掉没有的部分

*/

public boolean retainAll(Collection<?> c) {

Objects.requireNonNull©;

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++)

// 通过循环判断数组中有没有指定数组中的每一个值，complement 是参数传递的

if (c.contains(elementData[r]) == complement)

// 就将原数组的r位置的数据覆盖掉w位置的数据

// r位置的数据不变，并其w自增，r自增

// 否则，r自增，w不自增

// 本质：把需要移除的数据都替换掉，不需要移除的数据前移

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;

}

// writeObject readObject 序列化相关的省略

/**

• 列表迭代器：List集合特有的迭代器

*/

public ListIterator listIterator(int index) {

if (index < 0 || index > size)

throw new IndexOutOfBoundsException("Index: "+index);

return new ListItr(index);

}

public ListIterator listIterator() {

return new ListItr(0);

}

// foreach 遍历等同于 iterator

public Iterator iterator() {

return new Itr();

}

private class Itr implements Iterator {

// 下一个要访问的元素下标

int cursor;

// 上一个要访问的元素下标

int lastRet

《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》

【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享

= -1;

// 代表对 ArrayList 修改次数的期望值，初始值为 modCount

int expectedModCount = modCount;

Itr() {}

// 下标如果

public boolean hasNext() {

return cursor != size;

}

/**

• 刚开始cursor = 0，lastRet = -1

• 整个过程结束 cursor 和 lastRet 都会自增 1

*/

@SuppressWarnings(“unchecked”)

public E next() {

// 跳转本质是判断 modCount 是否等于 expectedModCount

checkForComodification();

int i = cursor;

// 判断 cursor 是否超过集合大小和数组长度

if (i >= size)

throw new NoSuchElementException();

Object[] elementData = ArrayList.this.elementData;

if (i >= elementData.length)

throw new ConcurrentModificationException();

cursor = i + 1;

// 将 cursor 赋值给 lastRet，然后把此下标处的元素返回

return (E) elementData[lastRet = i];

}

public void remove() {

// 先判断 lastRet 的值是否小于 0

if (lastRet < 0)

throw new IllegalStateException();

// 跳转本质是判断 modCount 是否等于 expectedModCount

checkForComodification();

try {

// 直接调用 ArrayList 的 remove 方法删除下标为 lastRet 的元素

ArrayList.this.remove(lastRet);

cursor = lastRet;

lastRet = -1;

expectedModCount = modCount;

} catch (IndexOutOfBoundsException ex) {

throw new ConcurrentModificationException();

}

}

// forEachRemaining 略

final void checkForComodification() {

if (modCount != expectedModCount)

throw new ConcurrentModificationException();

}

}

3. 重点内容分析

==========================================================================

3.1 扩容机制再分析

===========================================================================

3.1.1 ArrayList 是如何被初始化的

========================================================================================

ArrayList 提供了 1 个无参构造和 2 个带参构造来初始化 ArrayList ，我们在创建 ArrayList 时，经常使用无参构造的方式，其本质就是初始化了一个空数组，直到向数组内真的添加元素的时候才会真的去分配容量。例如：向数组中添加第一个元素，数组容量扩充为 10

补充：JDK7 无参构造 初始化 ArrayList 对象时，直接创建了长度是 10 的 Object[] 数组elementData

3.1.2 扩容机制流程分析（无参构造为例）

======================================================================================

3.1.2.1 add()

=============================================================================

一般来说，都是通过 add 方法触发扩容机制，我们拿最简单的尾部追加的 add() 方法举例

/**

• 将指定的元素追加到此列表的末尾。

*/

public boolean add(E e) {

// 确认 list 容量，尝试容量加 1，看看有无必要扩容

ensureCapacityInternal(size + 1); // Increments modCount!!

// 赋值

elementData[size++] = e;

return true;

}

核心要点就这一句 ensureCapacityInternal(size + 1);

3.1.2.2 ensureCapacityInternal()

================================================================================================

追踪进去

/**

• 得到最小扩容量

*/

private void ensureCapacityInternal(int minCapacity) {

ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));

}

方法内调用了 ensureExplicitCapacity() 方法，参数是 calculateCapacity(elementData, minCapacity)

先来分析一下这个参数的结果是什么，聚焦到 calculateCapacity() 方法中去

3.1.2.3 calculateCapacity()

===========================================================================================

/**

• 计算最小扩容量（被调用）

*/

private static int calculateCapacity(Object[] elementData, int minCapacity) {

// 如果元素数组为默认的空

if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

// 获取“默认的容量”和“传入参数 minCapacity ”两者之间的最大值

return Math.max(DEFAULT_CAPACITY, minCapacity);

}

return minCapacity;

}

也很简单，就是为了计算出一个最小扩容量，当元素为初次初始化时，数组还没进过扩容，是一个空数组，所以会走 if 这个判断，而且当时传入的 size + 1 也就是 minCapacity 的值为 0 + 1 = 1 ，经过一个取大值的操作，与默认的 DEFAULT_CAPACITY 进行比对，自然返回的就是 10。

如果数组已经不是为空了，就直接返回一个 minCapacity （size + 1）就可以了

3.1.2.4 ensureExplicitCapacity

==============================================================================================

ensureCapacityInternal 方法内调用了 ensureExplicitCapacity(参数已经计算出来了) 方法

继续去看它

/**

• 判断是否需要扩容

*/

private void ensureExplicitCapacity(int minCapacity) {

modCount++;

// overflow-conscious code

// 如果最小容量比数组的长度还大

if (minCapacity - elementData.length > 0)

// 就调用grow方法进行扩容

grow(minCapacity);

}

此方法的核心就是 if 判断这个数组需不需要扩容，可以分为三种情况

• add 第 1 个元素时：此时数组还只是一个被初始化过的空数组，minCapacity 经过calculateCapacity 计算会返回 DEFAULT_CAPACITY 的默认值 10，而 elementData.length 也自然是 0，所以 minCapacity - elementData.length > 0 是成立的，直接进入 grow(minCapacity); 开始扩容。

• add 第 2 到 10 个元素的时候（以 2 举例）：此时 minCapacity = size + 1 = 1 + 1 = 2 ，而 elementData.length 已经在添加第 1 个元素后等于 10 了。所以 minCapacity - elementData.length > 0 就不成立了，所以不会进入grow(minCapacity); ，也不会扩容添加第 3 … 10 个元素的时候，都是一样的。

• add 第 11 个元素的时候，minCapacity 变成了 11，比 10 还要大，所以又一次进去扩容了

3.1.2.5 grow()

==============================================================================

这里是真正去执行扩容逻辑的代码

/**

• 要分配的最大数组大小

*/

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**

• ArrayList 扩容的核心方法

*/

private void grow(int minCapacity) {

// 将当前元素数组长度定义为 oldCapacity 旧容量

int oldCapacity = elementData.length;

// 新容量更新为旧容量的1.5倍

// oldCapacity >> 1 为按位右移一位，相当于 oldCapacity 除以2的1次幂

int newCapacity = oldCapacity + (oldCapacity >> 1);

// 然后检查新容量是否大于最小需要容量，若还小，就把最小需要容量当作数组的新容量

if (newCapacity - minCapacity < 0)

newCapacity = minCapacity;

// 再检查新容量是否超出了ArrayList 所定义的最大容量

if (newCapacity - MAX_ARRAY_SIZE > 0)

// 若超出，则调用hugeCapacity()

newCapacity = hugeCapacity(minCapacity);

elementData = Arrays.copyOf(elementData, newCapacity);

}

扩容的核心就是这句： int

newCapacity = oldCapacity + (oldCapacity >> 1);

本质就是扩容 1.5 倍，而且其中使用了移位运算，这里从计算的角度上来看，相当于 oldCapacity 除以 2 的 1 次幂（偶数除以 2 刚好除尽，奇数丢掉小数部分）。使用按位右移，效率会高很多

按位右移运算符：最高位为 0，左边补齐 0，最高位是 1，左边补齐 1

• 快速计算：把 >> 左边的数据 除以 2 的移动次幂：例如 -24 >> 2 即：-24 / 2 ^ 2 = -6

—— 此项目 【001-Java基础知识】 章节中有具体介绍

扩容后，需要对这个新容量的范围进行一个判断，不能小于最小需要容量，也不能大于定义的最大容量，分情况细细看一下（以 1 和 11 举例，是因为这两种都是刚好需要扩容的）

• add 第 1 个元素的时候，数组还为空，所以无论是 oldCapacity 还是 newCapacity 都是 0，经过第一次判断后，newCapacity = minCapacity 执行了，此时 newCapacity 为 10，第二个判断不会进入，它不可能大于数组的最大容量。

• add 第 11 个元素的时候，oldCapacity 为 10，newCapacity = 10 + 10/2 = 15，大于 minCapacity = 11，第一个判断不会进入，同时它肯定也没有大于数组最大 size，不会进入 。数组容量此时就扩为 15，add 方法中会返回一个 true，size 也增加成 11。

• 后面都是同样的道理 …

3.1.2.6 hugeCapacity()

======================================================================================

这个方法就是在 newCapacity 大于 MAX_ARRAY_SIZE 的时候，开始判断 minCapacity 和 MAX_ARRAY_SIZE 谁大，然后赋予不同的值。

/**

• 比较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;

}

3.2 System.arraycopy() 和 Arrays.copyOf() 复制方法

=============================================================================================================

在前面的方法中，大量的用到了这两个方法，基本但凡涉及到元素移动的都会用到。

3.2.1 System.arraycopy()

========================================================================================

拿 add 方法中的举例

/**

• 在此列表中的指定位置插入指定的元素

• 再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。

*/

public void add(int index, E element) {

// 调用 rangeCheckForAdd 对 index 进行范围检查

rangeCheckForAdd(index);

// 保证容量足够

ensureCapacityInternal(size + 1); // Increments modCount!!

// 自己复制自己，然后达到 index 之后全部元素向后挪一位的效果

System.arraycopy(elementData, index, elementData, index + 1,

size - index);

// 然后将 index 赋值为指定的元素

elementData[index] = element;

size++;

}

arraycopy 是 System类 中的一个方法

/**

• 数组复制

• src - 源数组。

• srcPos - 源数组中的起始位置。

• dest - 目标数组。

• destPos - 目的地数据中的起始位置。

• length - 要复制的数组元素的数量。

*/

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

举例：

public static void main(String[] args) {

int[] arr = new int[10];

arr[0] = 11;

arr[1] = 22;

arr[2] = 33;

arr[3] = 44;

arr[4] = 55;

System.out.println(“前：” + Arrays.toString(arr));

// 指定下标后向后挪动一位

System.arraycopy(arr, 1, arr, 2, 4);

// 指定下标处替换元素

arr[1] = 666;

System.out.println(“后：” + Arrays.toString(arr));

}

运行结果：

前：[11, 22, 33, 44, 55, 0, 0, 0, 0, 0]

后：[11, 666, 22, 33, 44, 55, 0, 0, 0, 0]

这样就实现了 add 中的一个指定下标插入操作（不考虑扩容）

3.2.2 Arrays.copyOf()

=====================================================================================

所以，可以简单的认为，这个方法的目的只要是为了给原数组扩容。

public static void main(String[] args) {

int[] arr1 = {1, 2, 3, 4, 5};

int[] arr2 = Arrays.copyOf(arr1, 5);

int[] arr3 = Arrays.copyOf(arr1, 10);

System.out.println(Arrays.toString(arr1));

System.out.println(Arrays.toString(arr2));

System.out.println(Arrays.toString(arr3));

}

运行结果：

[1, 2, 3, 4, 5]

[1, 2, 3, 4, 5]

[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

3.3 removeAll() 和 retainAll() 中的 batchRemove() 方法

=================================================================================================================

在 removeAll() 和 retainAll() 方法中，都调用了 batchRemove()方法，区别只是传参不同，就能实现两种不同的正反删除效果

/**

• 从此列表中删除指定集合中包含的所有元素。

*/

public boolean removeAll(Collection<?> c) {

Objects.requireNonNull©;

return batchRemove(c, false);

}

/**

• 仅保留此列表中包含在指定集合中的元素。即删掉没有的部分

*/

public boolean retainAll(Collection<?> c) {

Objects.requireNonNull©;

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 {

if (r != size) {

System.arraycopy(elementData, r,

elementData, w,

size - r);

w += size - r;

}

if (w != size) {

for (int i = w; i < size; i++)

elementData[i] = null;

modCount += size - w;

size = w;

modified = true;

}

}

return modified;

}

解释一下刚开始的那些字段

• size ：原数组长度

• elementData： 原数组

• modCount ： 从父类继承过来的变量，作用是记录着集合的修改次数。

来看第一个关键代码

for (; r < size; r++)

if (c.contains(elementData[r]) == complement)

elementData[w++] = elementData[r];

我们以 removeAll() 为例，意图从此列表中删除指定集合中包含的所有元素。即，有的就删，没有的就不删。

所以 complement 经过参数传递过来自然是 false，所以参数指定数组中不含有原数组指定位置下标的数据的时候，就将 elementData[r] 位置的数据覆盖掉 elementData[w++] 位置的数据，r 根据循环++自增，w 根据变量 w++ 自增，若 if 表达式不成立则，r 自增，w 不自增。

举例：原数组：[1, 2, 3, 4, 5, 6, 7, 8, 9] ，指定参数数组： [a, b, c, 3, 5, 8, f]（ 例子参考自 ）重新排版

自己走一遍上面的逻辑，就能深刻的感受得到

这步的作用：把需要移除的数据都替换掉，不需要移除的数据前移。（这步的处理尤为重要！）

接下来进入 finally 中，这一段是最终肯定会执行的

if (r != size) {

System.arraycopy(elementData, r,elementData, w,size - r);

w += size - r;

}

if (w != size) {

for (int i = w; i < size; i++)

elementData[i] = null;

modCount += size - w;

size = w;

modified = true;

}

首先判断 r 是否等于 size，如果上面的循环正常执行结束，r 和 size 应该是相同的，所以肯定不会走上面，第一个 if 判断的目的就是为了解决某种异常情况下（异常，并发修改）导致的 for 循环未结束，此时 r != size 所以通过 arraycopy 将添加的元素追加到w索引后面。

而第二个 if ，主要是为了把 w 之后没处理过的给删掉，这样就可以达到目的了。

例如上面表格的例子，最后 w = 6，也就是 [1, 2, 4, 6, 7, 9, 7, 8, 9] 中从下标为 6 的元素 7 开始删除，将 7，8，9 赋值为 null 后面会被 GC 清理掉。最后得到的结果 [1, 2, 4, 6, 7, 9] 就是清除过的了 。

3.4 并发修改异常问题探索

==============================================================================

public static void main(String[] args) {

// 创建集合对象

List list = new ArrayList();

// 存储元素

list.add(“I”);

list.add(“love”);

list.add(“you”);

Iterator it = list.iterator();

while (it.hasNext()) {

String s = (String) it.next();

if (“love”.equals(s)) {

list.add(“❤”);

}

System.out.println(s);

}

}

//运行结果(节选)

Exception in thread “main” java.util.ConcurrentModificationException

使用增强for或者迭代器遍历集合的时候，如果对集合进行 list的 remove 和 add 操作，会出现 ConcurrentModificationException 并发修改异常的问题。

3.4.1 原因解释：

===========================================================================

当我们对集合进行遍历的时候，我们会获取当前集合的迭代对象

//List为例，获取集合的迭代对象

Iterator it = list.iterator();

这个迭代对象中，封装了迭代器的方法与集合本身的一些方法，当我们在迭代中使用集合本身的add / remove方法的时候，就产生了ConcurrentModificationException异常，通俗的说就是，在判断 equals 成功后，执行了 list 的 add / remove 方法， 操作集合中元素或者删除增加了，但是迭代器不清楚，所以就报错，如果迭代器中含有这一种方法（假设），我们是用迭代器添加元素就不会有问题了。

详细解释：

=====================================================================

• 开始时，cursor 指向下标为 0 的元素，lastRet 指向下标为 -1 的元素，每次调用 next 方法，cursor 和 lastRet 会分别自增 1。

• 当突然 ArrayList 的 remove 方法被调用（不是 Itr 的 remove），会导致被删除元素后面的所有元素都会往前移动一位，且 modCount 这个修改次数会增加，继续循环，去执行 next 方法，而 next 方法中首先判断的就是 modCount 和 expectedModCount 是否相等，很明显由于 ArrayList 的操作，导致 modCount 变化，两者现在已经不等了，所以出现异常

final void checkForComodification() {

if (modCount != expectedModCount)

throw new ConcurrentModificationException();

}

针对这个问题，我们给出两个解决方案

3.4.2 解决方案：

===========================================================================

3.4.2.1 方式1：迭代器迭代元素，迭代器修改元素

===========================================================================================

我们假想如果Iterator迭代器中有添加或者删除等功能就好了，但很遗憾并没有，但是它的子接口 ListIterator 却拥有 add 这个功能（ListIterator 拥有 add、set、remove 方法，Iterator 拥有 remove 方法，这里只演示 add 方法，remove 方法就用原来的 Iterator .remove() ）

ListIterator 的 add()和 Iterator 的 remove() 可以使用的原因都是因为，方法进行了添加删除操作后，都会执行 expectedModCount = modCount 这样的赋值操作，相当于告诉迭代器我进行了修改操作。

public static void main(String[] args) {

// 创建集合对象

List list = new ArrayList();

// 存储元素

list.add(“I”);

list.add(“love”);

list.add(“you”);

ListIterator lit = list.listIterator();

while (lit.hasNext()) {

String s = (String) lit.next();