通常在删除Java集合中的元素时有会出现安全删除和不安全删除，本案例以list集合为例，list集合的特点：元素无序、可以出现重复的元素。下面就为大家带来一篇java中循环删除list中元素的方法总结。
安全的删除元素：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
//方案一：for循环
for (int i = 0; i < list.size(); i++) {
if ("c".equals(list.get(i))) {
list.remove(i);
}
}
//方案二：通过一个迭代器
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String word = iterator.next();
if ("e".equals(word)) {
iterator.remove();
}
}
// 通过流的方式打印输出
list.stream().forEach(System.out::println);
}
}
输出：
a
b
d
再看不安全的删除元素：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("c");
list.add("d");
list.add("e");
// 方案一：通过for循环
for (int i = 0;i<list.size();i++){
if ("c".equals(list.get(i))){
list.remove(i);
}
}
//方案二：通过一个迭代器
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String word = iterator.next();
if ("c".equals(word)) {
iterator.remove();
}
}
// 通过流的方式打印输出
list.stream().forEach(System.out::println);
}
}
方案一输出：
a
b
c
d
e
方案二输出：
a
b
d
e
通过对比方案一与方案二发现，通过for循环删除集合元素时，当集合中有两个相邻的相同的元素时，是无法删除干净的，而迭代器可以删除干净。
原理：
list的集合是由数组实现的，当第一次遍历的时候，下标为2的值等于c，,就将下标为2的值删除掉，
删除掉后，数组会做一次迁移，后面的元素要往前移动
迁移后的数组：
下一次循环的时，i的值就等于3，下标为3的是就不是等于c了，所以就会删除不掉。
再看一组不安全删除元素：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("c");
list.add("d");
// 增强型for循环 删除元素c
for (String str : list) {
if ("c".equals(str))
list.remove(str);
}
// 通过流的方式打印输出
list.stream().forEach(System.out::println);
}
}
输出：
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at Test.main(Test.java:16)
Process finished with exit code 1
从运行结果来看，抛出了并发修改异常，它是怎么出现的?
源码：
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
通过源码可以看出是真实的修改次数与期待的修改次数不想等，我们只需要关心，为什么这两个值会不想等呢，
在对集合进行添加和修改时，都汇修改mdCount的值，那也就是说在遍历前呢，集合中的mdCount就是5，
我们添加的5个元素
增强for循环内部是使用的Iterator来遍历的，只能遍历数组和实现了Iterable接口的集合。优点是写法简便，无需获得数组、集合长度，也无需根据索引来访问元素。缺点是不能在循环里动态的删除元素和获取元素下标。
所以我们来看一下迭代器是如何实现的
由源码可以看出，Iterator直接将mdCoun值t赋值给expectedModCount，所以一开始，这两个值是想等的，
但是呢，在循环过程中会删除一个元素，mdCount的值就会自增1变成6，而expectedModCount还是5,此时mdCount就不等expectedModCount，所以就会抛出一个并发修改异常。
那么如何在遍历的同时安全的删除集合中的元素呢？才有JDK8推出的新接口removeIf
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("c");
list.add("d");
//采用removeIf接口，lambda表达式
list.removeIf(str -> str.equals("c"));
// 通过流的方式打印输出
list.stream().forEach(System.out::println);
}
}
输出：
a
b
d
removeIf 源码：
/**
*
* @param filter 传入的lambda表达式
* @return
*/
default boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
boolean removed = false;
final Iterator<E> each = iterator();
while (each.hasNext()) {
if (filter.test(each.next())) {
//如果执行结果是 true
each.remove(); //remove
removed = true;
}
}
return removed;
}
##总结
安全删除元素：
- 循环删除list中多个元素的，应该使用迭代器iterator方式。
- 使用普通for循环可以删除不相同元素
- 使用jdk8推出的新接口removeIf接口
不安全删除元素：
- 使用普通for循环删除相同元素会删除不干净
- 使用增强for循环删除元素会抛出并发修改异常