详解遍历集合和遍历集合时删除集合元素

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了详解遍历集合和遍历集合时删除集合元素相关的知识，希望对你有一定的参考价值。

参考技术A

集合遍历有多种方式，但各种方式执行效率上稍有差别，遍历集合时删除元素处理不当会有一些问题，这里详细汇总一下。

遍历集合元素的方式主要有以下几种：

这里以ArrayList为例来测试以上几种方式。
先创建一个集合元素类。

再创建一个遍历集合的测试类：

在我的 i5-6500 CPU电脑上多次测试取遍历操作耗时的平均值，得出这几种方法的遍历速度从快到慢依次为：

所以 如果遍历一个集合中元素，建议优先使用Java 8为Iterable接口提供的forEach默认方法。如果你还未使用Java 8，则建议优先使用Iterator接口的hasNex和next方法来实现遍历 。

遍历集合删除集合元素的方式有以下几种：

这里以ArrayList为例来测试以上几种方式。

在我的电脑上多次测试取耗时的平均值，得出这几种方法的遍历速度从快到慢依次为：

其中，iteratorRemove和forRemoveNoSkipping的测试结果很接近，大家可以自行修改集合大小的常量亲自测试，如有问题欢迎反馈。

所以 如果遍历一个集合时删除其中的元素，建议优先使用Java 8提供的流式API来筛选集合元素。如果你还未使用Java 8，则建议优先使用逆序的一般for循环来实现遍历时删除集合元素 。

许多初学者容易使用上面示例中的前三种方式来在遍历集合时删除集合元素，但是得不到正确的结果，原因已经在这三种方法的注释中说明了。对于使用for-each循环时抛出ConcurrentModificationException异常的原因可通过查看ArrayList.remove()方法的源码来探明。for-each循环List集合时使用了一个实现了Iterator接口的ArrayList内部类对象来实现遍历，该内部类源码如下：

使用for-each遍历时调用该内部类的next方法，进而调用该方法中第一行的checkForComodification方法，ConcurrentModificationException异常就是在这个checkForComodification方法中抛出的：

当我们显式调用remove方法来删除集合中的元素时会修改modCount的值，使其与expectedModCount不一致：

官方教程 也有说在以下情况中可以使用Iterator来代替for-each循环：

Java 集合（ListSet）遍历判断删除元素时的小陷阱

开发中，常有场景：遍历集合，依次判断是否符合条件，如符合条件则删除当前元素。

不知不觉中，有些陷阱，不知你有没有犯。

 

1. 一、漏网之鱼-for循环递增下标方式遍历集合，并删除元素

如果你用for循环递增下标方式遍历集合，在遍历过程中删除元素，你可能会遗漏了某些元素。说那么说可能也说不清楚，看以下示例：

技术分享
import java.util.ArrayList;
import java.util.List;

public class ListTest_Unwork {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        System.out.println("Original list : " + list);

        String temp = null;
        for (int i = 0; i < list.size(); i++) {
            temp = list.get(i);
            
            System.out.println("Check for " + temp);
            if ("3".equals(temp)) {
                list.remove(temp);
            }
        }
        System.out.println("Removed  list : " + list);
    }

}
技术分享

 

日志打印：

技术分享
Original list : [1, 2, 3, 4, 5]
Check for 1
Check for 2
Check for 3
Check for 5
Removed  list : [1, 2, 4, 5]
技术分享

如日志所见，其中值为4的元素并未经过判断，漏网之鱼。

 

解决方法为以下两个（但一般不建议我们在遍历中用不是遍历本身的函数删除元素，见下节关于“ConcurrentModificationException”的内容）：

1、对于此情况，我一般都从后面开始遍历，以避免问题：

技术分享
import java.util.ArrayList;
import java.util.List;

public class ListTest_Work {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        System.out.println("Original list : " + list);
        System.out.println();

        String temp = null;
        for (int i = list.size() - 1; i >= 0; i--) {
            temp = list.get(i);
            
            System.out.println("Check for " + temp);
            if ("3".equals(temp)) {
                list.remove(temp);
            }
        }
        System.out.println("Removed  list : " + list);
    }

}
技术分享

 

2、直接从新创建一个集合，重新摆放，但消耗内存，慎用：

技术分享
import java.util.ArrayList;
import java.util.List;

public class ListTest_Work2 {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        System.out.println("Original list : " + list);
        System.out.println();

        List<String> tempList = new ArrayList<String>();
        for (String temp : list) {
            System.out.println("Check for " + temp);
            if (!"3".equals(temp)) {
                tempList.add(temp);
            }
        }
        System.out.println("Removed  list : " + tempList);
    }

}
技术分享

 

 

2. 二、ConcurrentModificationException异常-Iterator遍历集合过程中用其他手段（或其他线程）操作元素

ConcurrentModificationException是Java集合的一个快速报错（fail-fast）机制，防止多个线程同时修改同一个集合的元素。在用Iterator遍历集合时，如果你用其他手段（非Iterator自身手段）操作集合元素，就会报ConcurrentModificationException。

不信？用Iterator方式或简写的for(Object o : list) {}方式，遍历集合，修改元素时会报异常：

技术分享
import java.util.ArrayList;
import java.util.List;

public class ListTest2_Unwork {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        System.out.println("Original list : " + list);
        System.out.println();

        for (String temp : list) {
            System.out.println("Check for " + temp);
            if ("3".equals(temp)) {
                list.remove(temp);
            }
        }
        System.out.println("Removed  list : " + list);
    }

}
技术分享

或

技术分享
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListTest3_Unwork {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        System.out.println("Original list : " + list);
        System.out.println();

        Iterator<String> i = list.iterator();
        String temp = null;
        while (i.hasNext()) {
            temp = i.next();
            System.out.println("Check for " + temp);
            if ("3".equals(temp)) {
                list.remove(temp);
            }
        }
        System.out.println("Removed  list : " + list);
    }

}
技术分享

 日志：

技术分享
Original list : [1, 2, 3, 4, 5]

Check for 1
Check for 2
Check for 3
Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859)
    at java.util.ArrayList$Itr.next(ArrayList.java:831)
    at ListTest3_Unwork.main(ListTest3_Unwork.java:20)
技术分享

在删除元素“3”时，会报异常。

 

对于此情况，需要用iterator的remove方法替代，结果是妥妥的：

技术分享
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListTest3_Work {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        System.out.println("Original list : " + list);
        System.out.println();

        Iterator<String> i = list.iterator();
        String temp = null;
        while (i.hasNext()) {
            temp = i.next();
            System.out.println("Check for " + temp);
            if ("3".equals(temp)) {
                i.remove();
            }
        }
        System.out.println("Removed  list : " + list);
    }

}
技术分享

 

延伸个小问题，为什么for(Object o : list) {}方式遍历集合，现象和Iterator方式一样，都会报错呢？

答：这是因为Java的糖语法，“for(Object o : list) {}方式”只是Java语言用“易用性糖衣”吸引你的手段，本质上，它也是Iterator。不信，你写下下面这段程序，反编译看看就清楚了：

技术分享 
package com.nichagil.test.forloop;

import java.util.ArrayList;
import java.util.List;

public class ForTester {
    
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("a");
        
        for (String s : list) {
            list.remove(s);
            System.out.println(s);
        }
    }

}
技术分享
package com.nichagil.test.forloop;

import java.util.ArrayList;
import java.util.List;

public class ForTester {
    
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("a");
        
        for (String s : list) {
            list.remove(s);
            System.out.println(s);
        }
    }

}
技术分享

 

反编译后是这样的：

技术分享 
package com.nichagil.test.forloop;

import java.util.ArrayList;
import java.util.Iterator;

public class ForTester {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("a");
        Iterator arg2 = list.iterator();

        while (arg2.hasNext()) {
            String s = (String) arg2.next();
            list.remove(s);
            System.out.println(s);
        }

    }
}
技术分享
package com.nichagil.test.forloop;

import java.util.ArrayList;
import java.util.Iterator;

public class ForTester {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("a");
        Iterator arg2 = list.iterator();

        while (arg2.hasNext()) {
            String s = (String) arg2.next();
            list.remove(s);
            System.out.println(s);
        }

    }
}

以上是关于详解遍历集合和遍历集合时删除集合元素的主要内容，如果未能解决你的问题，请参考以下文章

Java 集合（ListSet）遍历判断删除元素时的小陷阱

java 遍历集合的时候对集合进行操作

java集合遍历删除指定元素异常分析总结

搬砖系列如何在遍历List时安全删除集合元素

数组如何一边遍历一边删除元素

集合遍历过程iterator， 添加删除元素报异常