public static void show() { ArrayList<String> list= new ArrayList<String>(); list.add("a1"); list.add("a2"); list.add("a3"); Iterator<String> it = list.iterator(); while(it.hasNext()){   list.add("a4");   System.out.println(it.next());    }

迭代时怎么就出现异常了，感觉写得合情合理又合法啊

List集合在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生并发访问异常(ConcurrentModificationException异常)。
所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator的方法是有限的，只能对元素进行判断，取出，删除操作。
如果想要其他的操作如：添加，修改等，就需要使用其 子接口ListIterator，该接口只能通过List集合的ListIterator接口获取。

1.         public static void main(String []args){
   
2.                
   
3.                 ArrayList al = new ArrayList();
   
4.                
   
5.                 al.add("java01");
   
6.                 al.add("java02");
   
7.                 al.add("java03");
   
8.                 al.add("java04");
   
9.                 al.add("java04");
   
10. 
    
11.                 ListIterator it = al.listIterator();
    
12.                 sop(al);
    
13. 
    
14.                 while(it.hasNext()){//正向遍历列表
    
15.                         Object obj = it.next();
    
16.                         if(obj.equals("java02")){
    
17.                                 it.add("java08");
    
18.                         }
    
19.                 }
    
20.                 sop(al);
    
21.                 sop(it.hasPrevious());
    
22.                 while(it.hasPrevious()){//反向遍历列表
    
23.                         Object obj = it.previous();
    
24.                         if(obj.equals("java02")){
    
25.                                 it.add("java08");
    
26.                         }
    
27.                         
    
28.                 }
    
29.                 sop(al);
    
30. /*               
    
31.                 //在迭代过程中，准备添加或者删除元素
    
32.                
    
33.                 Iterator it = al.iterator();
    
34.                 sop(al);
    
35.                 while(it.hasNext()){
    
36.                         Object obj = it.next();
    
37.                         if(obj.equals("java02")){//不能同时用迭代器和集合操作方法操作集合。
    
38. //                                al.add("java03");        //并发访问异常。ConcurrentModificationException
    
39.                                 it.remove();
    
40.                                 
    
41.                         }
    
42.                         sop(obj);        
    
43.                 }
    
44.                 sop("al:"+al);
    
45. */               
    
46.                
    
47.         }

复制代码

这是并发操作异常

我的理解是这样的

1. import java.util.ArrayList;
   
2. import java.util.Iterator;
   
3. 
   
4. public class It {
   
5. 
   
6.         /**
   
7.          * @param args
   
8.          */
   
9.         public static void main(String[] args) {
   
10.                 // TODO Auto-generated method stub
    
11.                 show();
    
12.         }
    
13.         public static void show() {
    
14.                  ArrayList<String> list= new ArrayList<String>();
    
15.                  list.add("a1");
    
16.                 list.add("a2");
    
17.                  list.add("a3");
    
18.                  Iterator<String> it = list.iterator();//这是含有三个元素的集合的迭代器
    
19.                  while(it.hasNext()){
    
20.                
    
21.                          list.add("a4");   //此时list中已经含有四个元素了
    
22.                    System.out.println(it.next());        //集合内容已经更改了，那么它的迭代器也就无效了          
    
23.                  }
    
24.         }
    
25. }
    

复制代码

在while里面写，会不停的add，陷入死循环，我觉得是这样