Java 基础集合遍历删除 for与foreach区别

来源：互联网发布：淘宝买手机靠谱吗编辑：程序博客网时间：2024/06/01 23:32

在日常Java 开发中,想要在遍历中删除一个集合中的元素,这是很常见的,但是如果用法不当,那么就会导致系统存在一些隐式bug ! 笔者今天拿list 举例来分析一下,Java 中集合应如何正确删除.

1. 错误删除方式示例:

1.1 在for each 循环体中遍历删除

[java] view plain copy
/** 不可行方案一:  for each 循环删除方式 
 *  会抛出异常:ConcurrentModificationException,表示当前迭代对象不能修改 
 */  
@Test(expected=java.util.ConcurrentModificationException.class)  
public void test_clear_error_1(){  
    List<String> list = creatStringList();  
    for (String str : list) {  
        list.remove(str);  
    }  
}  

1.2. for 循环正序遍历删除

[java] view plain copy
/** 不可行方案二:  for 循环正序删除法 
 *  此中方式不会报运行错误,但是会有逻辑错误,因为没删除一个元素list.size()都在改变, 
 *  所以结果会少删除元素,循环的总次数并不是list.size() 
 */  
@Test  
public void test_clear_error_2(){  
    List<String> list = creatStringList();  
    for(int i=0; i<list.size(); i++){  
        list.remove(i);  
    }  
    System.out.println(list);  
}  

1.3. for 循环正序遍历删除2

[java] view plain copy
/** 不可行方案三:  for 循环正序删除法 -- list长度使用变量保存 
 *  会报数组下标越界异常, 因为list的长度在动态减少 
 */  
@Test(expected=java.lang.IndexOutOfBoundsException.class)  
public void test_clear_error_3(){  
    List<String> list = creatStringList();  
    int length = list.size();  
    for(int i=0; i<length; i++){  
        list.remove(i);  
    }  
    System.out.println(list);  
}  

2. 正确删除方案

1. for 循环遍历删除

[java] view plain copy
/** 可行方案一:  for 循环倒序删除法  
 *  性能最高 
 * */  
@Test  
public void test_clear_right_1(){  
    List<String> list = creatStringList();  
    for(int i=list.size() -1 ; i>=0; i--){  
        list.remove(i);  
    }  
    System.out.println(list);  
}  

2. iterator 迭代删除

[java] view plain copy
/** 可行方案二: iterator 变量删除 */  
@Test  
public void test_clear_right_2(){  
    List<String> list = creatStringList();  
    Iterator<String> iterator = list.iterator();  
    while(iterator.hasNext()){  
        iterator.remove();  
    }  
    System.out.println(list);  
}  

3. removeAll 删除

[java] view plain copy
/** 可行方案三: removeAll()  
 *  写法最简单,性能最差,可查看源代码:  
 *  java.util.ArrayList.batchRemove(Collection<?> c, boolean complement) 
 */  
@Test  
public void test_clear_right_3(){  
    List<String> list = creatStringList();  
    list.removeAll(list);  
    System.out.println(list);  
}  

3. 总结

1. 在删除set , collection 时也是一样的,推荐使用倒序删除方法.

2. 在只需要删除一个元素的时候,for 循环正序删除也可以实现,但是在一次for 循环中删除多个的话,就会出现问题.所以建议在删除一个元素的时候,也使用倒序删除法.

如何正确遍历删除List中的元素，你会吗？

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

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

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

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

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

[java] view plain copy
/**  
 * 使用增强的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
/**  
 * 像这种使用增强的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
/**  
 * 这种不使用增强的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
/**  
 * 使用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);    
}    

for与foreach区别参见

http://blog.csdn.net/heyuchang666/article/details/49683615

http://blog.csdn.net/u010031673/article/details/51800339

1、使用foreach来遍历集合时，集合必须实现Iterator接口，foreach就是使用Iterator接口来实现对集合的遍历的

2、在用foreach循环遍历一个集合时不能向集合中增加元素，不能从集合中删除元素，否则会抛出ConcurrentModificationException异常。抛出该异常是因为在集合内部有一个modCount变量用于记录集合中元素的个数，当向集合中增加或删除元素时，modCount也会随之变化，在遍历开始时会记录modCount的值，每次遍历元素时都会判断该变量是否发生了变化，如果发生了变化则抛出ConcurrentModificationException异常

阅读全文

0 0