java 的集合删除
罪恶之根源-设计如此
ArrayList<Integer> array = new ArrayList<>();
array.add(1);
array.add(2);
array.add(2);
array.add(3);
for (Integer a : array) {
if (2 == a){
array.remove(a);
}
System.out.println(a);
}
上面的代码运行出现下面的ConcurrentModificationException
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at com.tom.offer.jcf.LIterrator.main(LIterrator.java:58)
知道的人说这是发生了ConcurrentModificationException的异常。但是这样写为啥就发生异常了呢？
有的人说java集合的删除就是要用迭代器。要这样删除：
ArrayList<Integer> array = new ArrayList<>();
array.add(1);
array.add(2);
array.add(2);
array.add(3);
// for (Integer a : array) {
// if (2 == a){
// array.remove(a);
// }
// System.out.println(a);
// }
Iterator<Integer> iterator = array.iterator();
while(iterator.hasNext()){
Integer next = iterator.next();
if(next == 2){
iterator.remove();
}
}
System.out.println();
array.forEach(v -> System.out.print(v + " ")); //1 3
原因之谜
原先使用c++的时候，对于iterator++或iterator--使用的挺爽，java的iterator.next()到如今还是觉得陌生。
为啥使用迭代器删除就没错，使用集合自己的删除方法就错了呢？
原因在于我觉得是java的集合框架就是这样设计的。迭代器就是这样设计的。
首先看看 ArrayList的迭代器实现
/**
* An optimized version of AbstractList.Itr
*/
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
// 注意这里是把ArrayList的modCount赋值给了迭代器的expectedModCount
int expectedModCount = modCount;
Itr() {
}
/**
* 仅仅是判断迭代器当前的位置cursor 和ArrayList的size
*/
public boolean hasNext() {
return cursor != size;
}
/**
* 就看成是迭代器的iter++
*/
@SuppressWarnings("unchecked")
public E next() {
//检查1
checkForComodification();
int i = cursor;
//检查2
if (i >= size)
throw new NoSuchElementException();
//这里真的感觉不好，啥蹩脚语法ArrayList.this.elementData;
// 没有C++优雅
Object[] elementData = ArrayList.this.elementData;
//检查3
if (i >= elementData.length)
throw new ConcurrentModificationException();
// 干正事：iter++
cursor = i + 1;
return (E) elementData[lastRet = i];
}
/**
* 迭代器的删除
*/
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
//检查1
checkForComodification();
try {
// 调用ArrayList的remove
// 他会modCount++，然后移动数组
ArrayList.this.remove(lastRet);
// 把lastRet又给了cursor
cursor = lastRet;
//赋初值
lastRet = -1;
//把在ArrayList.this.remove(lastRet)中
//修改的modCount又赋值给了expectedModCount
//太不好的设计了。。。。。。。。。
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++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
/**
* ArrayList的remove
*/
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; // clear to let GC do its work
return oldValue;
}
通过源代码可以知道，iterator的next()方法会调用集合自己的remove()方法。
而集合自己的remove会增加modCount，next()在调用remove()后，
会把集合的modCount赋值给iterator的expectedModCount。
如下：
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();
}
}
因此对于代码块
for (Integer a : array) {
//这里实际上编译器是处理为迭代器 也就是
if (2 == a){
//for(Iterator<Integer> iter =
// array.iterator();iter.hasNext();){
array.remove(a); // Integer a = iter.enxt();
}
System.out.println(a);
}
在for循环中，一旦array.remove(a);他就会修改集合自己的modCount，
不会修改迭代器的expectedModCount 。
当再次运行到for循环中的next()的checkForComodification()
就会出现ConcurrentModificationException
迭代器删除就没错？？
看如下的代码：
List<String> list = new ArrayList<>();
list.add("123");
list.add("456");
list.add("567");
list.add("tom");
list.add("lixi");
System.out.println();
list.forEach(v -> System.out.print(v + " "));
Iterator<String> first = list.iterator();
Iterator<String> second = list.iterator();
for(; first.hasNext();){
String next = first.next();
if(next.equals("tom")){
first.remove();
}
}
System.out.println();
list.forEach(v -> System.out.print(v + " "));
for(; second.hasNext();){
//到这里，集合的modCount已经改变很多次了，
//但是迭代器second的expectedModCount还是最初的modCount，
//因此second.next()会出现ConcurrentModificationException
String next = second.next();
if(next.equals("tom")){
second.remove();
}
}
System.out.println();
list.forEach(v -> System.out.print(v + " "));
小结
我认为这样的设计不友好。