1.原始的for循环删除集合元素的时候有可能会漏掉某个元素
测试代码:
/**
* 假设需要删除集合中的所有的"A"元素
* 如果使用原始的for循环,那么就可能会漏删
*/
List<String> list = new ArrayList<>();
list.add("A");
list.add("A");
list.add("B");
for(int i=0; i<list.size(); i++) {
if("A".equals(list.get(i))) {
list.remove(i);
}
}
System.out.println(list);
输出结果:
[A, B]
可以看到集合中只有一个"A"被删了,第二个"A"却还在。
其实解决办法也很简单,在删除元素之后再加一行代码i- -就解决了
2.增强型for循环删除集合元素会报出ConcurrentModificationException异常
修改一下上面的测试代码
List<String> list = new ArrayList<>();
list.add("A");
list.add("A");
list.add("B");
for(String item : list) {
if("A".equals(item)) {
list.remove(item);
}
}
System.out.println(list);
打印结果是ConcurrentModificationException异常。
增强型for循环其实是编译器认可的语法,在到了虚拟机那边只认迭代器循环,所以在编译为.class文件的时候,最终还是变成了迭代器循环。通过反编译得到如下代码:
List<String> list = new ArrayList();
list.add("A");
list.add("A");
list.add("B");
Iterator var3 = list.iterator();
while(var3.hasNext()) {
String item = (String)var3.next();
if ("A".equals(item)) {
list.remove(item);
}
}
迭代器这块比较复杂,我们从源码上慢慢探索。
list.iterator()其实际上是获得了一个内部类ListItr对象,而ListItr其实是继承自另一个内部类Itr。循环所用到的hasnext(),next()方法都是在这个类中实现的。
private class Itr implements Iterator<E> {
/**
* Index of element to be returned by subsequent call to next.
*/
int cursor = 0;//这个就是类似于for循环中的int i,当调用了
//remove方法的时候会让cursor自减,这样可以保证不会漏掉任何一个元素
/**
* Index of element returned by most recent call to next or
* previous. Reset to -1 if this element is deleted by a call
* to remove.
*/
int lastRet = -1;
/**
* The modCount value that the iterator believes that the backing
* List should have. If this expectation is violated, the iterator
* has detected concurrent modification.
*/
int expectedModCount = modCount;//modCount是外部类的成员
//我的理解是这应该代表了该容器的修改次数
public boolean hasNext() {
return cursor != size();
}
public E next() {
checkForComodification();
try {
int i = cursor;
E next = get(i);
lastRet = i;
cursor = i + 1;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
//这是迭代器的remove方法
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
/**
* ArrayList的remove方法
*/
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++; //关键代码,这里的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
}
大概理一下抛出异常的思路:
modCount是集合的成员变量,初始值为1,当创建迭代器对象的时候,modCount会赋值给expectedModCount。当调用了list本身的remove方法的时候,expectedModCount会自增。而到了下一次迭代器的next方法去取集合元素的时候会先执行checkForComodification()方法判断版本号是否一致,如果集合的版本号和迭代器的版本号不一致就会抛出异常。
而如果是调用迭代器的remove方法,它会先调用集合的remove方法,然后执行cursor- -,再把modCount赋值给expectedModCount。这样一来既保证了下一次迭代的时候不会漏过任何元素,也避免了next方法校对版本号的时候抛出异常