ArrayList 源码分析(含扩容机制分析)
1. ArrayList 概述
1.1 List 是什么?
List
在 Collection
中充当有序的集合(也称为序列)。实现该接口的用户可以精确控制元素的插入位置,支持通过整数索引访问元素,并在列表中搜索元素。与 Set
不同,列表通常允许重复的元素。
1.2 ArrayList 是什么?
ArrayList
的底层实现是一个数组,依赖扩容机制实现动态增长。它的特点包括:
- 查询速度快
- 增删操作相对较慢
- 线程不安全
- 效率高
1.3 顺序表的优缺点
优点:
- 逻辑与物理顺序一致,能够快速按下标存取元素。
- 不需额外存储空间表示元素之间的逻辑关系。
缺点:
- 长度需初始定义,难以确定存储空间容量,扩容降低效率。
- 插入和删除操作需移动大量元素,效率较低。
1.4 时间复杂度证明
- 读取:时间复杂度为 O(1)。
- 插入和删除:
- 最好情况(末尾插入):O(1)
- 最坏情况(开头插入):O(n)
- 平均情况:O(n)
总结:ArrayList
更适合处理元素个数相对稳定且查询频繁的情况。
2. 核心源码分析
2.1 类声明
ArrayList
继承了 AbstractList
类并实现了多个接口:
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
// 源码具体内容...
}
RandomAccess
:标志接口,表示支持快速随机访问。Cloneable
:支持克隆操作。java.io.Serializable
:支持序列化。
2.2 类成员
transient Object[] elementData;
:存储元素的数组。
// 序列化自动生成的一个码,用来在正反序列化中验证版本一致性。
private static final long serialVersionUID = 8683452581122892189L;
/**
* 默认初始容量大小为10
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 指定 ArrayList 容量为0(空实例)时,返回此空数组
*/
private static final Object[] EMPTY_ELEMENTDATA = {
};
/**
* 与 EMPTY_ELEMENTDATA 的区别是,它是默认返回的,而前者是用户指定容量为 0 才返回
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
};
/**
* 具体存放元素的数组
* 保存添加到 ArrayList 中的元素数据(第一次添加元素时,会扩容到 DEFAULT_CAPACITY = 10 )
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* ArrayList 实际所含元素个数(大小)
*/
private int size;
2.3 构造方法
- 无参构造器初始化容量为 0,添加第一个元素(扩充为10)。
- 带参构造器根据指定容量初始化。
/**
* 带参构造函数,参数为用户指定的初始容量
*/
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);
}
}
/**
* 默认无参构造函数,初始值为 0
* 也说明 DEFAULT_CAPACITY = 10 这个容量
* 不是在构造函数初始化的时候设定的(而是在添加第一个元素的时候)
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 构造一个包含指定 collection 的元素的列表
* 这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
*/
public ArrayList(Collection<? extends E> c) {
// 将给定的集合转成数组
elementData = c.toArray();
// 如果数组长度不为 0
if ((size = elementData.length) != 0) {
// elementData 如果不是 Object 类型的数据,返回的就不是 Object 类型的数组
if (elementData.getClass() != Object[].class)
// 将不是 Object 类型的 elementData 数组,赋值给一个新的 Object 类型的数组
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 数组长度为 0 ,用空数组代替
this.elementData = EMPTY_ELEMENTDATA;
}
}
2.4 扩容方法
扩容方法会在元素添加超过当前容量时被调用。
/**
* 增加ArrayList实例的容量,如果有必要,确保它至少可以保存由最小容量参数指定的元素数量。
*/
public void ensureCapacity(int minCapacity) {
//如果元素数组不为默认的空,则 minExpand 的值为0,反之值为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 static int calculateCapacity(Object[] elementData, int minCapacity) {
// 如果元素数组为默认的空
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 获取“默认的容量”和“传入参数 minCapacity ”两者之间的最大值
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
/**
* 得到最小扩容量
*/
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, 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 旧容量
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);
}
/**
* 比较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;
}
2.5 常规方法
/**
* 返回元素数量
*/
public int size() {
return size;
}
/**
* 此列表元素数量为 0 则返回 true
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 此列表含有指定元素,则返回true
*/
public boolean contains(Object o) {
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 {
// 本质就是循环 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> 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(c);
return batchRemove(c, false);
}
/**
* 仅保留此列表中包含在指定集合中的元素。即删掉没有的部分
*/
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++)
// 通过循环判断数组中有没有指定数组中的每一个值,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<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
public ListIterator<E> listIterator() {
return new ListItr(0);
}
// foreach 遍历等同于 iterator
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
// 下一个要访问的元素下标
int cursor;
// 上一个要访问的元素下标
int lastRet = -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
提供一个无参构造和两个带参构造。无参构造会初始化一个空数组,添加第一个元素时扩容为 10。
补充:JDK7 无参构造 初始化 ArrayList 对象时,直接创建了长度是 10 的 Object[] 数组elementData
3.1.2 扩容机制流程分析
-
add() 方法:通常通过
add()
方法触发扩容机制。/** * 将指定的元素追加到此列表的末尾。 */ public boolean add(E e) { // 确认 list 容量,尝试容量加 1,看看有无必要扩容 ensureCapacityInternal(size + 1); // Increments modCount!! // 赋值 elementData[size++] = e; return true; }
核心要点就这一句
ensureCapacityInternal(size + 1);
-
ensureCapacityInternal():调用
ensureExplicitCapacity()
,并传入计算出的容量。/** * 得到最小扩容量 */ private void ensureCapacityInternal(int minCapacity) { ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); }
-
calculateCapacity():计算最小扩容量。如果是空数组,返回 10。
/** * 计算最小扩容量(被调用) */ private static int calculateCapacity(Object[] elementData, int minCapacity) { // 如果元素数组为默认的空 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 获取“默认的容量”和“传入参数 minCapacity ”两者之间的最大值 return Math.max(DEFAULT_CAPACITY, minCapacity); } return minCapacity; }
-
ensureExplicitCapacity:判断是否需要扩容。
- 第一个元素时需要扩容。
- 之后的元素在容量足够时不再扩容。
/** * 判断是否需要扩容 */ private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code // 如果最小需要的容量比当前数组的长度还大 if (minCapacity - elementData.length > 0) // 就调用grow方法进行扩容 grow(minCapacity); }
-
grow():执行扩容,通常扩容为 1.5 倍。
/** * 要分配的最大数组大小 */ 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);
-
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():用于元素移动。
/** * 在此列表中的指定位置插入指定的元素 * 再将从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++; } /** * 数组复制 * src - 源数组。 * srcPos - 源数组中的起始位置。 * dest - 目标数组。 * destPos - 目的地数据中的起始位置。 * length - 要复制的数组元素的数量。 */ public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
-
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 并发修改异常问题探索
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.3.1 原因解释
当我们对集合进行遍历时,会获取当前集合的迭代对象:
// List为例,获取集合的迭代对象
Iterator<String> it = list.iterator();
这个迭代对象中封装了迭代器的方法与集合本身的一些方法。当我们在迭代中使用集合本身的 add
或 remove
方法时,会产生 ConcurrentModificationException
异常。通俗来说,在判断 equals
成功后,执行了集合的 add
或 remove
方法,导致集合中元素的添加或删除发生变化,但迭代器并不知情,因此会报错。
详细解释
- 开始时,
cursor
指向下标为 0 的元素,lastRet
指向下标为 -1 的元素。每次调用next
方法,cursor
和lastRet
会自增 1。 - 当突然调用
ArrayList
的remove
方法(而不是迭代器的remove
),会导致被删除元素后面的所有元素前移,并且modCount
变量增加。下一次调用next
方法时,首先会判断modCount
和expectedModCount
是否相等,若不相等,就会抛出异常。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
3.3.2 解决方案
虽然 Iterator
迭代器没有提供添加功能,但其子接口 ListIterator
却拥有 add
、set
和 remove
方法。在这里,我们仅演示 add
方法,而 remove
方法仍然使用 Iterator
的 remove()
。
ListIterator
的 add()
方法与 Iterator
的 remove()
方法能够安全使用的原因在于,进行添加或删除操作后,都会执行 expectedModCount = modCount
的赋值操作,这相当于告诉迭代器进行了修改操作,从而保持了状态一致性。
3.3.2.1 使用迭代器的 remove
方法
通过迭代器的 remove
方法进行删除,避免抛出异常。
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();
if ("love".equals(s)) {
// add 、remove 都是可以的
lit.add("❤");
}
System.out.print(s + " ");
}
System.out.println();
for (Object l : list){
System.out.print(l + " ");
}
}
//运行结果
I love you
I love ❤ you
3.3.2.2 使用 ListIterator
进行添加和删除
ListIterator
支持在遍历时进行添加和删除操作,能够安全地避免异常。
public static void main(String[] args) {
// 创建集合对象
List<String> list = new ArrayList<>();
// 存储元素
list.add("I");
list.add("love");
list.add("you");
// 使用 ListIterator 遍历
ListIterator<String> lit = list.listIterator();
while (lit.hasNext()) {
String s = lit.next();
if ("love".equals(s)) {
lit.add("❤"); // 安全地添加元素
}
System.out.print(s + " ");
}
}
// 运行结果
// I love ❤ you
3.3.2.3 集合遍历元素,集合修改元素(普通for)
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList();
//存储元素
list.add("I");
list.add("love");
list.add("you");
for (int x = 0; x < list.size(); x++){
String s = (String)list.get(x);
if ("love".equals(s)){
list.add("❤");
}
System.out.print(s + " ");
}
}
//运行结果
I love you ❤
3.3.3 iterator.remove() 的弊端
-
Iterator
只支持remove()
方法,不能add
。 -
remove()
方法的使用限制:- 在调用
remove()
方法之前,必须先调用next()
方法。这是因为remove()
会依赖于next()
方法返回的当前元素。如果没有调用next()
,lastRet
的值将仍为 -1,调用remove()
时会抛出IllegalStateException
- 在调用
-
remove()
的调用限制: -
next()
方法调用后只能调用一次remove()
。调用remove()
会将lastRet
重新初始化为 -1,这意味着在再次调用next()
之前,不能再调用remove()
,否则会导致异常。
ls(s)) {
lit.add(“❤”); // 安全地添加元素
}
System.out.print(s + " ");
}
}
// 运行结果
// I love ❤ you
##### 3.3.2.3 集合遍历元素,集合修改元素(普通for)
```java
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList();
//存储元素
list.add("I");
list.add("love");
list.add("you");
for (int x = 0; x < list.size(); x++){
String s = (String)list.get(x);
if ("love".equals(s)){
list.add("❤");
}
System.out.print(s + " ");
}
}
//运行结果
I love you ❤
3.3.3 iterator.remove() 的弊端
-
Iterator
只支持remove()
方法,不能add
。 -
remove()
方法的使用限制:- 在调用
remove()
方法之前,必须先调用next()
方法。这是因为remove()
会依赖于next()
方法返回的当前元素。如果没有调用next()
,lastRet
的值将仍为 -1,调用remove()
时会抛出IllegalStateException
- 在调用
-
remove()
的调用限制: -
next()
方法调用后只能调用一次remove()
。调用remove()
会将lastRet
重新初始化为 -1,这意味着在再次调用next()
之前,不能再调用remove()
,否则会导致异常。