1. import java.util.*;
   
2. 
   
3. 
   
4. // 要求： 查找集合中有没有zhangsan这个字符串。如果有，则再添加一个lisi进去。
   
5. 
   
6. public class ListDemo {
   
7.         public static void main(String[] args) {
   
8.                 // 创建集合对象
   
9.                 List<String> list = new ArrayList<String>();
   
10. 
    
11.                 list.add("zhaoliu");
    
12.                 list.add("zhangsan");
    
13.                 list.add("wangwu");
    
14. 
    
15.                
    
16.                 // 普通for循环
    
17.                 for (int x = 0; x < list.size(); x++) {
    
18.                         String s = list.get(x);
    
19.                         if ("zhangsan".equals(s)) {
    
20.                                 list.add("lisi");
    
21.                         }
    
22.                 }
    
23.                 System.out.println("list:" + list);
    
24.                
    
25.                 System.out.println("******************************************");
    
26. 
    
27.                 //增强for循环
    
28.                 for(String s :list){
    
29.                         if ("zhangsan".equals(s)) {
    
30.                                 list.add("lisi");
    
31.                         }
    
32.                 }
    
33.                 System.out.println("list:" + list);
    
34.         }
    
35. }
    

复制代码

运行结果如下：

用普通for时没有问题，增强for就出现了异常，请问该如何修改？

刚看我也奇怪，于是在网上找了下原因，原来是因为：
在遍历集合过程中，增强for循环不能对集合本身进行操作
    for (String str : set) {
     set.remove(str);//错误！
    }
我把你的增强for循环改写了一下，里面改成System.out.println(s);，可以打印出zhangsan，说明除了增删操作外都可以正常使用

blackcaismine 发表于 2013-3-20 10:58
刚看我也奇怪，于是在网上找了下原因，原来是因为：
在遍历集合过程中，增强for循环不能对集合本身进行操作 ...

我试过直接打印输出可以正常操作，就是不明白这个增删该如何改

类似于线程安全吧，使用Iterator迭代过程中也不可以使用集合自身的
增删方法，要使用迭代器的方法。原来增强for循环也有这个问题

原因在这里啊：
at java.util.AbstractList$Itr.checkForComodification(Unknown Source)
at java.util.AbstractList$Itr.next(Unknown Source)

在AbstractList$Itr这个类中实现了Iterator接口，当使用增强的for循环时，
应该是使用迭代器进行迭代了，如果你在这期间使用了add方法的话，在ArrayList类中执行了这样的代码

1. public boolean add(E e) {
   
2.         ensureCapacity(size + 1);  // Increments modCount!!
   
3.         elementData[size++] = e;
   
4.         return true;
   
5.     }

复制代码

1. public void ensureCapacity(int minCapacity) {
   
2.         modCount++;
   
3.         int oldCapacity = elementData.length;
   
4.         if (minCapacity > oldCapacity) {
   
5.             Object oldData[] = elementData;
   
6.             int newCapacity = (oldCapacity * 3)/2 + 1;
   
7.                 if (newCapacity < minCapacity)
   
8.                 newCapacity = minCapacity;
   
9.             // minCapacity is usually close to size, so this is a win:
   
10.             elementData = Arrays.copyOf(elementData, newCapacity);
    
11.         }
    
12.     }

复制代码

这里的modCount增加了，但是迭代器中的next方法时，

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.         }

复制代码

先checkForComodification();

1. final void checkForComodification() {
   
2.             if (modCount != expectedModCount)
   
3.                 throw new ConcurrentModificationException();
   
4.         }
   
5.     }

复制代码

因此抛出了异常。。。

在遍历集合时，增强for的遍历是封装了迭代器的试遍历方式，
如果你明白为什么迭代时不能使用用集合的方式添加或删除元素,应该会明白这里为什么会发生异常了