基础增强部分张老师给我们讲了JDK1.5新特性，for增强foreach，
我们知道foreach运算比for要快不少，甚至有时候比c++的都要快，
不足之处就是只能从左往右单向遍历，并且不能多层迭代。
当然还有个最大的不足就是只能查询不能改变原值。
下面有个例子报了个想不同的错误：

1.         public static void main(String[] args) {
   
2.                 List<String> list = new ArrayList<String>();
   
3.                 list.add("1");
   
4.                 list.add("2");
   
5.                 list.add("3");
   
6.                 list.add("4");
   
7.                 for (String string : list) {// java.util.ConcurrentModificationException？？------>我下面try、catch了为嘛这里还给我报错呢，下面的删掉就不会出错了！
   
8.           if (string.equals("2")) {
   
9.                                 try {
   
10.                                         list.remove(string);
    
11.                                 } catch (Exception e) {
    
12.                                         e.printStackTrace();
    
13.                                         System.out.println("出错了");
    
14.                                 }
    
15.                         }
    
16.                 }
    
17.                 System.out.println(list);
    
18.         }

复制代码

为啥呢

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

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

复制代码

刚看了一下毕老师的视频，这个异常是并发修改异常，
我测试了一下是foreach跟list.remove(string);
一起调用出的错，改成for就没问题了！
难道foreach跟iterator的实现原理一样么？
都会跟集合自己的方法出现并发修改异常！！


楼下的来回答下

封号了... 发表于 2013-8-16 19:41
刚看了一下毕老师的视频，这个异常是并发修改异常，
我测试了一下是foreach跟list.remove(string);
一起调 ...

高级for跟迭代是一样的效果