遍歷刪除List中的元素有很多種方法，當運用不當的時候就會產生問題。下面主要看看以下幾種遍歷刪除List中元素的形式：

1.通過增強的for迴圈刪除符合條件的多個元素

2.通過增強的for迴圈刪除符合條件的一個元素

3.通過普通的for刪除刪除符合條件的多個元素

4.通過Iterator進行遍歷刪除符合條件的多個元素

1. /** 
2.  * 使用增強的for迴圈 
3.  * 在迴圈過程中從List中刪除元素以後，繼續迴圈List時會報ConcurrentModificationException 
4.  */  
5. public void listRemove() {  
6.     List<Student> students = this
   .getStudents();  
7.     for (Student stu : students) {  
8.         if (stu.getId() == 2)   
9.             students.remove(stu);  
10.     }  
11. }  

1. /** 
2.  * 像這種使用增強的for迴圈對List進行遍歷刪除，但刪除之後馬上就跳出的也不會出現異常 
3.  */  
4. public void listRemoveBreak() {  
5.     List<Student> students = this.getStudents();  
6.     for (Student stu : students) {  
7.         if (stu.getId() == 2) {  
8.             students.remove(stu);  
9.             break;  
10.         }  
11.     }  
12. }  

1. /** 
2.  * 這種遍歷有可能會遺漏某個元素,因為刪除元素後List的size在 
3.  * 變化，元素的索引也在變化，比如你迴圈到第2個元素的時候你把它刪了， 
4.  * 接下來你去訪問第3個元素，實際上訪問到的是原先的第4個元素。當訪問的元素 
5.  * 索引超過了當前的List的size後還會出現陣列越界的異常，當然這裡不會出現這種異常， 
6.  * 因為這裡每遍歷一次都重新拿了一次當前List的size。
    
7.  */  
8. public void listRemove2() {  
9.     List<Student> students = this.getStudents();  
10.     for (int i=0; i<students.size(); i++) {  
11.         if (students.get(i).getId()%3 == 0) {  
12.             Student student = students.get(i);  
13.             students.remove(student);  
14.         }  
15.     }  
16. }  

1. /** 
2.  * 使用Iterator的方式也可以順利刪除和遍歷 
3.  */  
4. public void iteratorRemove() {  
5.     List<Student> students = this.getStudents();  
6.     System.out.println(students);  
7.     Iterator<Student> stuIter = students.iterator();  
8.     while (stuIter.hasNext()) {  
9.         Student student = stuIter.next();  
10.         if (student.getId() % 2 == 0)  
11.             stuIter.remove();//這裡要使用Iterator的remove方法移除當前物件，如果使用List的remove方法，則同樣會出現ConcurrentModificationException  
12.     }  
13.     System.out.println(students);  
14. }  

附完整程式碼如下：

1. import java.util.ArrayList;  
2. import java.util.Iterator;  
3. import java.util.List;  
4. public class ListRemove {  
5.     public static void main(String args[]) {  
6.         ListRemove lr = new ListRemove();  
7.         lr.listRemove();  
8.         lr.listRemoveBreak();  
9. //      lr.listRemove2();  
10. //      lr.iteratorRemove();  
11.     }  
12.     /** 
13.      * 使用增強的for迴圈 
14.      * 在迴圈過程中從List中刪除元素以後，繼續迴圈List時會報ConcurrentModificationException 
15.      */  
16.     public void listRemove() {  
17.         List<Student> students = this.getStudents();  
18.         for (Student stu : students) {  
19.             if (stu.getId() == 2)   
20.                 students.remove(stu);  
21.         }  
22.     }  
23.     /** 
24.      * 像這種使用增強的for迴圈對List進行遍歷刪除，但刪除之後馬上就跳出的也不會出現異常 
25.      */  
26.     public void listRemoveBreak() {  
27.         List<Student> students = this.getStudents();  
28.         for (Student stu : students) {  
29.             if (stu.getId() == 2) {  
30.                 students.remove(stu);  
31.                 break;  
32.             }  
33.         }  
34.     }  
35.     /** 
36.      * 這種不使用增強的for迴圈，每次重新獲取list的size遍歷的情況執行時不會報錯，但是可能刪除的結果是錯的。 
37.      */  
38.     public void listRemove2() {  
39.         List<Student> students = this.getStudents();  
40.         for (int i=0; i<students.size(); i++) {  
41.             if (students.get(i).getId()%2 == 0)  
42.                 students.remove(i);  
43.         }  
44.     }  
45.     /** 
46.      * 使用Iterator的方式也可以順利刪除和遍歷 
47.      */  
48.     public void iteratorRemove() {  
49.         List<Student> students = this.getStudents();  
50.         System.out.println(students);  
51.         Iterator<Student> stuIter = students.iterator();  
52.         while (stuIter.hasNext()) {  
53.             Student student = stuIter.next();  
54.             if (student.getId() % 2 == 0)  
55.                 stuIter.remove();  
56.         }  
57.         System.out.println(students);  
58.     }  
59.     private List<Student> getStudents() {  
60.         List<Student> students = new ArrayList<Student>() {  
61.             {  
62.                 int i = 0;  
63.                 while (i++ < 10) {  
64.                     Student student = new Student(i, "201200" + i, "name_" + i);  
65.                     this.add(student);  
66.                 }  
67.             }  
68.         };  
69.         return students;  
70.     }  
71. }  

1. public class Student {  
2.     private int id;  
3.     private String stuNo;  
4.     private String name;  
5.     public Student() {  
6.     }  
7.     public Student(int id, String stuNo, String name) {  
8.         this.id = id;  
9.         this.stuNo = stuNo;  
10.         this.name = name;  
11.     }  
12.     public int getId() {  
13.         return id;  
14.     }  
15.     public void setId(int id) {  
16.         this.id = id;  
17.     }  
18.     public String getStuNo() {  
19.         return stuNo;  
20.     }  
21.     public void setStuNo(String stuNo) {  
22.         this.stuNo = stuNo;  
23.     }  
24.     public String getName() {  
25.         return name;  
26.     }  
27.     public void setName(String name) {  
28.         this.name = name;  
29.     }  
30.     @Override  
31.     public String toString() {  
32.         return "Student [id=" + id + ", name=" + name + ", stuNo=" + stuNo  
33.                 + "]";  
34.     }  
35. }