首页 > 代码库 > Iterator的remove方法可保证从源集合中安全地删除对象（转）

Iterator的remove方法可保证从源集合中安全地删除对象（转）

2024-07-06 10:41:04   223人阅读

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorTest{
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Test1");
        list.add("Test2");
        list.add("Test3");
        list.add("Test4");
        list.add("Test5");
        
        for(Iterator<String> it = list.iterator();it.hasNext();){
            if(it.next().equals("Test3")){
                it.remove();
            }
        }
        
        for(String s : list){
            System.out.println(s);
        }
        
    }
}

Iterator 支持从源集合中安全地删除对象，只需在 Iterator 上调用 remove() 即可。这样做的好处是可以避免 ConcurrentModifiedException ，这个异常顾名思意：当打开 Iterator 迭代集合时，同时又在对集合进行修改。
有些集合不允许在迭代时删除或添加元素，但是调用 Iterator 的remove() 方法是个安全的做法。

 

java.util.ConcurrentModificationException详解

http://blog.csdn.net/smcwwh/article/details/7036663

 

【引言】

经常在迭代集合元素时，会想对集合做修改(add/remove)操作，类似下面这段代码：

for (Iterator<Integer> it = list.iterator(); it.hasNext(); ) {
    Integer val = it.next();
    if (val == 5) {
        list.remove(val);
    }
}

运行这段代码，会抛出异常java.util.ConcurrentModificationException。

【解惑】

(以ArrayList来讲解)在ArrayList中，它的修改操作(add/remove)都会对modCount这个字段+1，modCount可以看作一个版本号，每次集合中的元素被修改后，都会+1(即使溢出)。接下来再看看AbsrtactList中iteraor方法

public Iterator<E> iterator() {
    return new Itr();
}

 

它返回一个内部类，这个类实现了iterator接口，代码如下：

private class Itr implements Iterator<E> {
    int cursor = 0;

    int lastRet = -1;

    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size();
    }

    public E next() {
        checkForComodification();
        try {
            E next = get(cursor);
            lastRet = cursor++;
            return next;
        } catch (IndexOutOfBoundsException e) {
            checkForComodification();
            throw new NoSuchElementException();
        }
    }

    public void remove() {
        if (lastRet == -1)
            throw new IllegalStateException();
        checkForComodification();

        try {
            AbstractList.this.remove(lastRet);
            if (lastRet < cursor)
                cursor--;
            lastRet = -1;
            // 修改expectedModCount 的值
            expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
            throw new ConcurrentModificationException();
        }
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
    }

在内部类Itr中，有一个字段expectedModCount ，初始化时等于modCount，即当我们调用list.iterator()返回迭代器时，该字段被初始化为等于modCount。在类Itr中next/remove方法都有调用checkForComodification()方法，在该方法中检测modCount == expectedModCount，如果不相当则抛出异常ConcurrentModificationException。

前面说过，在集合的修改操作(add/remove)中，都对modCount进行了+1。
在看看刚开始提出的那段代码，在迭代过程中，执行list.remove(val)，使得modCount+1，当下一次循环时，执行 it.next()，checkForComodification方法发现modCount != expectedModCount，则抛出异常。

【解决办法】
如果想要在迭代的过程中，执行删除元素操作怎么办？
再来看看内部类Itr的remove()方法，在删除元素后，有这么一句expectedModCount = modCount，同步修改expectedModCount 的值。所以，如果需要在使用迭代器迭代时，删除元素，可以使用迭代器提供的remove方法。对于add操作，则在整个迭代器迭代过程中是不允许的。 其他集合(Map/Set)使用迭代器迭代也是一样。

 

 

 

 

 

 




 

 

 

 

 

1、

 

今天在写一个带缓存功能的访问代理程序时出现了java.util.ConcurrentModificationException异常， 因为该异常是非捕获型异常而且很少见，所以费了些时间才找到问题所在，原来在通过Iterator进行遍历的时候，如果直接对HashMap进行操作后，再继续用之前的Iterator进行遍历就会出现这个异常，表示其HashMap已经被修改。

 

源程序代码片段如下：caches为一个HashMap对象

 

      String sameKeyPart = accesserClassName + "@" + methodName + "@" + parameterKeyString + "@";
      Iterator keys = caches.keySet().iterator();
      String key = null;
      while (keys.hasNext()) ...{
        key = (String) keys.next();
        if (key.startsWith(sameKeyPart)) ...{
          caches.remove(key);
        }
      }

 

解决办法为通过其相应的Iterator进行删除就可以了，修改后代码片段如下：

 

      String sameKeyPart = accesserClassName + "@" + methodName + "@" + parameterKeyString + "@";
      Iterator keys = caches.keySet().iterator();
      String key = null;
      while (keys.hasNext()) ...{
        key = (String) keys.next();
        if (key.startsWith(sameKeyPart)) ...{
          keys.remove();
        }
      }

 

2、

撰写多线程代码时，你遇到过多少次下面的提示： Exception in thread "main" java.util.ConcurrentModificationException    

这个异常产生的原因有几个。一是直接对集合调用删除操作而不是在枚举器上。二是不同的线程试图对集合进行增删操作的时候。

这个解决办法的第一步就是同步代码，使得你在枚举的时候其它的线程不能增删记录。但是如果每个枚举过程要进行复杂的计算或者是数据库访问的一部分的话，这个同步就会导致可怕的后果。为了减少负面影响，可以拷贝一个只读的枚举器，去掉同步，然后采用下列代码所示的方法：

 

  private List list;
  public void add(Object obj) {
  synchronized(list) {
  list.add(obj);
  }
  }
  public void perform( ) {
  Iterator iterator = null;
  synchronized(list) {
  iterator = new CopiedIterator(list.iterator( ));
  }
  while(iterator.hasNext( )) {
  // perform resource or cpu hungry work
  }
  }

 

重要的是记住，CopiedIterator不是一个克隆，只是一个只读的拷贝，所以它并没有保持原有的全部功能。最重要的是，不能再调用CopiedIterator.remove方法了。CopiedIterator.remove的实现如下：

 public class CopiedIterator implements Iterator {
  private Iterator iterator = null;
  public CopiedIterator(Iterator itr) {
  LinkedList list = new LinkedList( );
  while(itr.hasNext( )) {
  list.add(itr.next( ));
  }
  this.iterator = list.iterator( );
  }
  public boolean hasNext( ) {
  return this.iterator.hasNext( );
  }
  public void remove( ) {
  throw new UnsupportedOperationException("This is a read-only iterator.
  ");
  }
  public Object next( ) {
  return this.iterator.next( );
  }
  }

 

枚举器的只读拷贝将用在同步状态上的时间减少到最小，因此可以增强全局的效率。

 

3、

 

当使用 fail-fast iterator 对 Collection 或 Map 进行迭代操作过程中尝试直接修改 Collection / Map 的内容时，即使是在单线程下运行，  java.util.ConcurrentModificationException 异常也将被抛出。 　　Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。

 

　　所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。

 

　　有意思的是如果你的 Collection / Map 对象实际只有一个元素的时候， ConcurrentModificationException 异常并不会被抛出。这也就是为什么在 javadoc 里面指出： it would be wrong to write a program that depended on this exception for its correctness: ConcurrentModificationException should be used only to detect bugs.

 

 

 

 

 

 

 

 

 

 

 


联系
我们