来自http://www.blogjava.net/fingki/archive/2010/03/02/314268.html

在使用Iterator处理Collection时，注意java.util.ConcurrentModificationException。
1.如果你仅仅是对collection进行遍历查询，那么不必担心什么。
2.但如果你在遍历过程中要对collection进行删除，那么你就要注意了。
For example:
private void testDel() {  

1.     List<String> list = new ArrayList<String>();  
2.     for (int i = 0; i < 10; i++) {  
3.         String str = "td" + i;  
4.         list.add(str);  
5.     }  
6.   
7.     for (Iterator it = list.iterator(); it.hasNext();) {  
8.         String str = (String) it.next();  
9.         if (str.equals("td5")) {  
10.             // list.remove(str);  // 删除方法一 
    
11.             it.remove();  // 删除方法二 
    
12.         }  
13.     }  
14. } 
    

上面的代码运行没有问题，但如果你用“方法一”替代“方法二”，则会出现 java.util.ConcurrentModificationException。
（用for-each遍历也会出个类似问题）
具体原因是可以看一下先看看List中的remove方法源码：

1. public boolean remove(Object o) {  
2.     if (o == null) {  
3.         for (int index = 0; index < size; index++)  
4.             if (elementData[index] == null) {  
5.                 fastRemove(index);  
6.                 return true;  
7.             }  
8.     } else {  
9.         for (int index = 0; index < size; index++)  
10.             if (o.equals(elementData[index])) {  
11.                 fastRemove(index);  
12.                 return true;  
13.             }  
14.     }  
15.     return false;  
16. }  
17.   
18. private void fastRemove(int index) {  
19.     modCount++; // 特别注意这里，这里只增加了modCount的值  
20.     int numMoved = size - index - 1;  
21.     if (numMoved > 0)  
22.         System.arraycopy(elementData, index + 1, elementData, index,  
23.                 numMoved);  
24.     elementData[--size] = null; // Let gc do its work  
25. } 
    

接着看。删除后得到下一个元素的代码，it.next():  it为AbstractList的内部类Iterator的一个实例。

1. public E next() {  
2.     checkForComodification();  
3.     try {  
4.         E next = get(cursor);  
5.         lastRet = cursor++;  
6.         return next;  
7.     } catch (IndexOutOfBoundsException e) {  
8.         checkForComodification();  
9.         throw new NoSuchElementException();  
10.     }  
11. }  
12.   
13. final void checkForComodification() {  //注意这个方法
    
14.     if (modCount != expectedModCount)  //检查这两个值是否相同
15.         throw new ConcurrentModificationException();  
16. } 
    

最后看Iterator的remove()方法的源代码：

1. public void remove() {  
2.     if (lastRet == -1)  
3.         throw new IllegalStateException();  
4.     checkForComodification();  
5.     try {  
6.         AbstractList.this.remove(lastRet);  
7.         if (lastRet < cursor)  
8.             cursor--;  
9.         lastRet = -1;  
10.         expectedModCount = modCount; // 设置expectedModCount  
11.     } catch (IndexOutOfBoundsException e) {  
12.         throw new ConcurrentModificationException();  
13.     }  
14. }  
15.   
16. final void checkForComodification() {  
17.     if (modCount != expectedModCount)  
18.         throw new ConcurrentModificationException();  
19. } 
    

这下就明白了，list的remove方法只修改了modCount值，而iterator的remove能同步modCount和 expectedModCount.