遍历删除ArrayList中的元素

遍历删除List中的元素有很多种方法，当运用不当的时候就会产生问题。下面主要看看以下几种遍历删除List中元素的形式：

1.通过增强的for循环删除符合条件的多个元素

2.通过增强的for循环删除符合条件的一个元素

3.通过普通的for删除删除符合条件的多个元素

4.通过Iterator进行遍历删除符合条件的多个元素

 

[java] view plain copy

print ?

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

    /** 
     * 使用增强的for循环 
     * 在循环过程中从List中删除非基本数据类型以后，继续循环List时会报ConcurrentModificationException 
     */  
    public void listRemove() {  
        List<Student> students = this.getStudents();  
        for (Student stu : students) {  
            if (stu.getId() == 2)   
                students.remove(stu);  
        }  
    }  

[java] view plain copy

print ?

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

    /** 
     * 像这种使用增强的for循环对List进行遍历删除，但删除之后马上就跳出的也不会出现异常 
     */  
    public void listRemoveBreak() {  
        List<Student> students = this.getStudents();  
        for (Student stu : students) {  
            if (stu.getId() == 2) {  
                students.remove(stu);  
                break;  
            }  
        }  
    }  

[java] view plain copy

print ?

1. /**  
2.  * 这种不使用增强的for循环的也可以正常删除和遍历,  
3.  * 这里所谓的正常是指它不会报异常，但是删除后得到的  
4.  * 数据不一定是正确的，这主要是因为删除元素后，被删除元素后  
5.  * 的元素索引发生了变化。假设被遍历list中共有10个元素，当  
6.  * 删除了第3个元素后，第4个元素就变成了第3个元素了，第5个就变成  
7.  * 了第4个了，但是程序下一步循环到的索引是第4个，  
8.  * 这时候取到的就是原本的第5个元素了。  
9.  */    
10. public void listRemove2() {    
11.     List<Student> students = this.getStudents();    
12.     for (int i=0; i<students.size(); i++) {    
13.         if (students.get(i).getId()%3 == 0) {    
14.             Student student = students.get(i);    
15.             students.remove(student);    
16.         }    
17.     }    
18. }    

    /** 
     * 这种不使用增强的for循环的也可以正常删除和遍历, 
     * 这里所谓的正常是指它不会报异常，但是删除后得到的 
     * 数据不一定是正确的，这主要是因为删除元素后，被删除元素后 
     * 的元素索引发生了变化。假设被遍历list中共有10个元素，当 
     * 删除了第3个元素后，第4个元素就变成了第3个元素了，第5个就变成 
     * 了第4个了，但是程序下一步循环到的索引是第4个， 
     * 这时候取到的就是原本的第5个元素了。 
     */  
    public void listRemove2() {  
        List<Student> students = this.getStudents();  
        for (int i=0; i<students.size(); i++) {  
            if (students.get(i).getId()%3 == 0) {  
                Student student = students.get(i);  
                students.remove(student);  
            }  
        }  
    }  

[java] view plain copy

print ?

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

    /** 
     * 使用Iterator的方式可以顺利删除和遍历 
     */  
    public void iteratorRemove() {  
        List<Student> students = this.getStudents();  
        System.out.println(students);  
        Iterator<Student> stuIter = students.iterator();  
        while (stuIter.hasNext()) {  
            Student student = stuIter.next();  
            if (student.getId() % 2 == 0)  
                stuIter.remove();//这里要使用Iterator的remove方法移除当前对象，如果使用List的remove方法，则同样会出现ConcurrentModificationException  
        }  
        System.out.println(students);  
    }  

原文链接： http://haohaoxuexi.iteye.com/blog/1523785