import java.util.*;
class  IteratorDemo
{
        public static void main(String[] args) throws Exception
        {
                Collection c=new ArrayList();
                Iterator it=c.iterator();
                c.add("hello");
                c.add("world");
                c.add("java");

                System.out.println("c:"+c);
                while(it.hasNext())
                {
                        Object obj=it.next();
                        System.out.println(obj);
                }
        }
}
怎么会报这个异常？求解。。
ConcurrentModificationException

Exception in thread "main" java.util.ConcurrentModificationException：并发修改异常
在使用迭代器迭代元素的时候，不能使用集合去操作元素，否则，就会出现并发修改异常。
解决办法:
迭代器迭代的过程中，使用迭代器对象去添加元素。

这是一个非捕获型异常
通过Iterator进行遍历，如果直接对ArrayList集合进行操作后，再继续用之前的Iterator进行遍历就会出现这个异常，表示其ArrayList集合已经被修改
将Iterator那条语句放后面来就好了

1. import java.util.*;
   
2. class  IteratorDemo
   
3. {
   
4.         public static void main(String[] args) throws Exception
   
5.         {
   
6.                 Collection c=new ArrayList();
   
7.                 //Iterator it=c.iterator();
   
8.                 c.add("hello");
   
9.                 c.add("world");
   
10.                 c.add("java");
    
11. 
    
12.                 System.out.println("c:"+c);
    
13.                                 Iterator it=c.iterator();//------------该语句放在操作完之后
    
14.                 while(it.hasNext())
    
15.                 {
    
16.                         Object obj=it.next();
    
17.                         System.out.println(obj);
    
18.                 }
    
19.         }
    
20. }

复制代码

Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。

1. import java.util.*;
   
2. public class TestDemo {
   
3. 
   
4. 
   
5.                 public static void main(String[] args) throws Exception
   
6.                 {
   
7.                         Collection c=new ArrayList();
   
8.                         Iterator it=c.iterator();
   
9.                         c.add("hello");
   
10.                         c.add("world");
    
11.                         c.add("java");
    
12. 
    
13.                         System.out.println("c:"+c);
    
14.                     /*    while(it.hasNext())
    
15.                         {
    
16.                                 Object obj=it.next();
    
17.                                 System.out.println(obj);
    
18.                         }*/
    
19.                         for(Object o : c){
    
20.                             System.out.print(o);
    
21.                        }
    
22.                 }
    
23.         }
    
24. 
    

复制代码

--------------------------------------------
我觉得这样改动一样吧

  public static void main(String[] args) throws Exception
        {
               ArrayList c=new ArrayList();
              //  Iterator it=c.iterator();//提示：当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
                                                                               //因为你迭代集合的时候，你又去修改原集合（包括，添加，删除能引起原集合长度发生改变的都是不行），必然会引出问题。
                                                                               //如果要用，可以用迭代器提供的方法。
                c.add("hello");
                c.add("world");
                c.add("java");
                Iterator it=c.iterator();//这样就不会有那种现象了。
               
               System.out.println("c:"+c);
                while(it.hasNext())
                {
                        Object obj=it.next();
                        System.out.println(obj);
                }
        }
}

list集合你还没有添加的时候就用了集合c的对象
把 Iterator it=c.iterator();写在c.add之后就OK了