遍历删除List中的元素有很多种方法,当运用不当的时候就会产生问题。下面主要看看以下几种遍历删除List中元素的形式:
1.通过增强的for循环删除符合条件的多个元素
2.通过增强的for循环删除符合条件的一个元素
3.通过普通的for删除删除符合条件的多个元素
4.通过Iterator进行遍历删除符合条件的多个元素
- /**
- * 使用增强的for循环
- * 在循环过程中从List中删除元素以后,继续循环List时会报ConcurrentModificationException
- */
- public void listRemove() {
- List<Student> students = this.getStudents();
- for (Student stu : students) {
- if (stu.getId() == 2)
- students.remove(stu);
- }
- }
- /**
- * 像这种使用增强的for循环对List进行遍历删除,但删除之后马上就跳出的也不会出现异常
- */
- public void listRemoveBreak() {
- List<Student> students = this.getStudents();
- for (Student stu : students) {
- if (stu.getId() == 2) {
- students.remove(stu);
- break;
- }
- }
- }
- /**
- * 这种遍历有可能会遗漏某个元素,因为删除元素后List的size在
- * 变化,元素的索引也在变化,比如你循环到第2个元素的时候你把它删了,
- * 接下来你去访问第3个元素,实际上访问到的是原先的第4个元素。当访问的元素
- * 索引超过了当前的List的size后还会出现数组越界的异常,当然这里不会出现这种异常,
- * 因为这里每遍历一次都重新拿了一次当前List的size。
- */
- 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);
- }
- }
- }
- /**
- * 使用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);
- }
附完整代码如下:
- import java.util.ArrayList;
- import java.util.Iterator;
- import java.util.List;
- public class ListRemove {
- public static void main(String args[]) {
- ListRemove lr = new ListRemove();
- lr.listRemove();
- lr.listRemoveBreak();
- // lr.listRemove2();
- // lr.iteratorRemove();
- }
- /**
- * 使用增强的for循环
- * 在循环过程中从List中删除元素以后,继续循环List时会报ConcurrentModificationException
- */
- public void listRemove() {
- List<Student> students = this.getStudents();
- for (Student stu : students) {
- if (stu.getId() == 2)
- students.remove(stu);
- }
- }
- /**
- * 像这种使用增强的for循环对List进行遍历删除,但删除之后马上就跳出的也不会出现异常
- */
- public void listRemoveBreak() {
- List<Student> students = this.getStudents();
- for (Student stu : students) {
- if (stu.getId() == 2) {
- students.remove(stu);
- break;
- }
- }
- }
- /**
- * 这种不使用增强的for循环,每次重新获取list的size遍历的情况运行时不会报错,但是可能删除的结果是错的。
- */
- public void listRemove2() {
- List<Student> students = this.getStudents();
- for (int i=0; i<students.size(); i++) {
- if (students.get(i).getId()%2 == 0)
- students.remove(i);
- }
- }
- /**
- * 使用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();
- }
- System.out.println(students);
- }
- private List<Student> getStudents() {
- List<Student> students = new ArrayList<Student>() {
- {
- int i = 0;
- while (i++ < 10) {
- Student student = new Student(i, "201200" + i, "name_" + i);
- this.add(student);
- }
- }
- };
- return students;
- }
- }
- public class Student {
- private int id;
- private String stuNo;
- private String name;
- public Student() {
- }
- public Student(int id, String stuNo, String name) {
- this.id = id;
- this.stuNo = stuNo;
- this.name = name;
- }
- public int getId() {
- return id;
- }
- public void setId(int id) {
- this.id = id;
- }
- public String getStuNo() {
- return stuNo;
- }
- public void setStuNo(String stuNo) {
- this.stuNo = stuNo;
- }
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- @Override
- public String toString() {
- return "Student [id=" + id + ", name=" + name + ", stuNo=" + stuNo
- + "]";
- }
- }
- 转载:http://haohaoxuexi.iteye.com/blog/1523785
相关推荐
当你在一个迭代器正在遍历集合的过程中添加或删除元素时,就会抛出这个异常。这个问题在单线程环境下不会出现,但在多线程并发场景下,如果多个线程同时修改一个集合,就可能导致`ConcurrentModificationException`...
增强for循环是Java语法糖的一种体现,但是使用这种方法遍历删除元素也会出现问题,运行时会报ConcurrentModificationException异常。原因在于,在增强for循环中,实际上是使用Iterator来遍历List,而Iterator并不能...
在Java编程中,遍历并删除集合(如List或Set)中的元素是一项常见的操作,但如果不正确地执行,可能会导致`ConcurrentModificationException`异常。这个异常通常在尝试修改正在迭代的集合时出现,因为Java的集合迭代...
这段代码将抛出 `java.util.ConcurrentModificationException` 异常,因为在遍历 HashMap 的元素过程中删除了当前所在元素,下一个待访问的元素的指针也由此丢失了。 2. 正确的删除方法 正确的删除方法是使用迭代...
- 在多线程环境下,不要在遍历过程中修改HashMap,否则可能会抛出`ConcurrentModificationException`。如果需要在遍历中修改,可以使用`Iterator.remove()`方法,或者使用`CopyOnWriteArrayMap`等线程安全的集合。 -...
在面试中,除了基本的遍历方式,还可能考察一些高级话题,如并发遍历(ConcurrentModificationException)、性能优化(如避免在循环中调用`size()`方法)以及如何处理null元素等。同时,理解不同集合类的底层实现和...
这个示例代码尝试在遍历 ArrayList 时删除其中的一个元素,这将导致 ConcurrentModificationException 异常。 那么,为什么会抛出这个异常呢?我们可以通过查看 ArrayList 的源码来了解原因。ArrayList 的 iterator...
在Java编程中,遍历并删除List中的元素是一项常见的操作,但如果不小心处理,可能会遇到错误,如`ConcurrentModificationException`。以下是几种常见的遍历删除List元素的方法及其注意事项: 1. **通过增强的for...
- 在遍历`Map`时,如果在遍历过程中尝试修改`Map`(例如添加或删除元素),可能会引发`ConcurrentModificationException`异常。因此,在遍历的同时不要修改`Map`。 - 使用流API遍历时,虽然代码更简洁,但性能上可能...
在Java编程中,遍历并删除List集合是一个常见的操作,但在实际编程中,如果不使用正确的方法,可能会导致`java.util.ConcurrentModificationException`异常。本文主要针对这个面试题,详细讲解如何在遍历List的同时...
Java list利用遍历进行删除操作3种方法解析 Java list 是一种常用的数据结构,经常被用来存储和操作数据。在 Java 中,对 list 进行遍历和删除操作是一种常见的需求。本文将介绍 Java list 利用遍历进行删除操作的 ...
在Java编程中,集合类遍历的同时进行删除操作是一个常见的需求,但如果不正确地执行,可能会导致`ConcurrentModificationException`。这个问题主要出现在迭代器正在遍历集合时,集合本身被修改的情况。以下是对这个...
然而,当我们尝试在使用`Iterator`遍历集合的过程中直接修改集合时,可能会遇到`ConcurrentModificationException`异常。这个异常通常发生在多线程环境下对共享数据进行并发修改,但即使在单线程情况下,如果在迭代...
使用Iterator遍历ConcurrentHashMap可以避免ConcurrentModificationException的出现。这种方式的优点是可以安全地遍历Map的内容,并且可以在遍历过程中修改Map的内容。但是,需要注意的是,使用Iterator遍历需要手动...
hasNext() 方法用于判断集合中是否还有未被遍历的元素,next() 方法用于返回集合中的下一个元素,remove() 方法用于删除集合中的上一个元素。 Iterator 接口主要用于遍历集合元素,而不是提供盛装对象的能力。因此...
- **迭代器遍历**适用于需要遍历多种不同类型集合,且不希望暴露底层实现的场合,同时,它支持在遍历过程中删除元素。 - **foreach循环**则适用于代码简洁性优先,且不需要在遍历过程中修改集合的场景。 在性能方面...
如果在遍历过程中需要移除元素,必须使用`it.remove()`,直接调用`list.remove()`会导致并发修改异常(ConcurrentModificationException)。 ### 第二种:增强型for循环(foreach) ```java for (A a : list) { /...
- 遍历HashMap时修改HashMap(添加、删除元素)可能会导致`ConcurrentModificationException`,因为迭代器无法检测到这种并发修改。 - 使用`keySet()`遍历并删除元素是安全的,但效率较低,因为这涉及到两次查找:...
然而,在遍历 ArrayList 时,如果需要删除某些元素,可能会遇到 ConcurrentModificationException 异常。今天,我们将讨论如何正确地遍历和修改 ArrayList。 遍历 ArrayList 的正确方法 在遍历 ArrayList 时,不能...
注意,这种方式如果在遍历过程中删除键,可能会导致迭代器抛出`ConcurrentModificationException`异常。 4. **通过`entrySet()`遍历** 类似地,如果需要同时访问键和值,但不希望使用for-each循环,也可以使用`...