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

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

遍历集合

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

使用一般的for循环遍历集合
使用for-each循环遍历集合
使用Iterator迭代器提供的hasNext、next方法遍历集合
使用Java 8 为Iterator接口提供的forEachRemaining默认方法遍历集合
使用Java 8 为Iterable接口提供的forEach默认方法遍历集合
使用Java 8 提供的流式API遍历集合

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

public class Student {
    private int id;
    private String name;

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

   省略getter和setter方法
}

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

public class IterateCollectionTest {
    private static final int LIST_SIZE = 10000;
    private static final int ITERATE_TIMES = 1000;
    private static final int CONDITION_NUM = 2;

    public static void main(String[] args) {
        forIterate();
        forEachIterate();
        iteratorIterate();
        iteratorForEachRemainingMethodIterate();
        forEachMethodIterate();
        streamIterate();
    }

    /**
     * 使用一般的for循环遍历集合元素
     */
    public static void forIterate() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "student" + i));
        }

        long millionSeconds = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            Student student = list.get(i);
            if (student.getId() % CONDITION_NUM == 0) {
                for (int j = 0; j < ITERATE_TIMES; ) {
                    j++;
                }
            }
        }
        System.out.println("forIterate操作耗时：" + (System.currentTimeMillis() - millionSeconds));
    }

    /**
     * 使用for-each循环遍历集合元素
     */
    public static void forEachIterate() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "student" + i));
        }

        long millionSeconds = System.currentTimeMillis();
        for (Student student : list) {
            if (student.getId() % CONDITION_NUM == 0) {
                for (int j = 0; j < ITERATE_TIMES; ) {
                    j++;
                }
            }
        }
        System.out.println("forEachIterate操作耗时：" + (System.currentTimeMillis() - millionSeconds));
    }

    /**
     * 使用Iterator迭代器来遍历结合元素
     */
    public static void iteratorIterate() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "student" + i));
        }

        long millionSeconds = System.currentTimeMillis();
        Iterator<Student> iterator = list.iterator();
        while (iterator.hasNext()) {
            Student student = iterator.next();
            if (student.getId() % CONDITION_NUM == 0) {
                for (int j = 0; j < ITERATE_TIMES; ) {
                    j++;
                }
            }
        }
        System.out.println("iteratorIterate操作耗时：" + (System.currentTimeMillis() - millionSeconds));
    }

    /**
     * 使用Java 8 为Iterator接口提供的forEachRemaining默认方法来遍历集合元素
     * 该方法是使用Iterator的hasNext、next方法，以及函数式接口Consumer实现的
     * 该方法可依据指定的迭代顺序（如果指定了的话）来遍历处理集合元素，所以效率较低
     * 这里可以使用Java 8新增的Lambda表达式来简化编程
     */
    public static void iteratorForEachRemainingMethodIterate() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "student" + i));
        }

        long millionSeconds = System.currentTimeMillis();
        list.iterator().forEachRemaining(student -> {
            if (student.getId() % CONDITION_NUM == 0) {
                for (int j = 0; j < ITERATE_TIMES; ) {
                    j++;
                }
            }
        });
        System.out.println("iteratorForEachRemainingMethodIterate操作耗时：" + (System.currentTimeMillis() - millionSeconds));
    }

    /**
     * 使用Java 8 为Iterable接口提供的forEach默认方法来遍历集合元素
     * 该方法使用for-each循环来实现遍历，在这几种方法中速度最快
     * 这里可以使用Java 8新增的Lambda表达式来简化编程
     */
    public static void forEachMethodIterate() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "student" + i));
        }

        long millionSeconds = System.currentTimeMillis();
        list.forEach(student -> {
            if (student.getId() % CONDITION_NUM == 0) {
                for (int j = 0; j < ITERATE_TIMES; ) {
                    j++;
                }
            }
        });
        System.out.println("forEachMethodIterate操作耗时：" + (System.currentTimeMillis() - millionSeconds));
    }

    /**
     * 使用Java 8 提供的流式API来遍历集合
     * 流式API将集合转换成流，遍历速度仅次于Iterable接口提供的forEach默认方法。
     */
    public static void streamIterate() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "student" + i));
        }

        long millionSeconds = System.currentTimeMillis();
        list.stream().forEach(student -> {
            if (student.getId() % CONDITION_NUM == 0) {
                for (int j = 0; j < ITERATE_TIMES; ) {
                    j++;
                }
            }
        });
        System.out.println("streamIterate操作耗时：" + (System.currentTimeMillis() - millionSeconds));
    }
}

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

forEachMethodIterate > streamIterate > iteratorIterate > forEachIterate > forIterate > iteratorForEachRemainingMethodIterate

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

遍历集合时动态删除集合中的元素

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

使用一般的for循环遍历删除，同时手动处理因删除操作导致集合大小变化的问题
使用一般的for循环逆序遍历删除，不用手动处理因删除操作导致集合大小变化的问题
使用官方推荐的Iterator迭代器提供的Iterator.remove方法在遍历集合时删除集合元素
使用Java 8新增的removeIf方法在遍历集合时删除集合元素
使用Java 8提供的流式API来筛选元素，然后转换成集合类型

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

public class RemoveElementInListTest {
    private static final int LIST_SIZE = 20000;
    private static final int CONDITION_NUM = 2;

    public static void main(String[] args) {
        // 以下三种方式都不能正常地遍历删除
        // forEachRemove();
        // forEachBreakRemove();
        // forRemove();

        // 以下几种方式可以正常地遍历删除
        forRemoveNoSkipping();
        forReverseRemoveNoSkipping();
        iteratorRemove();
        ifRemove();
        streamRemove();
    }

    /**
     * 使用foreach遍历删除
     * 在第一次循环时删除List中的元素删除不会出现问题，但继续循环List时会报ConcurrentModificationException
     * 从打印的异常信息来看，forEach循环集合时使用了某种内部索引器
     * 可以使用线程安全的CopyOnWriteArrayList来代替ArrayList
     * 但是当List中元素很多时效率会大大折扣，还会造成资源浪费
     */
    public static void forEachRemove() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "Student" + i));
        }

        for (Student student : list) {
            if (student.getId() % CONDITION_NUM == 0) {
                list.remove(student);
            }
        }
    }

    /**
     * 使用foreach循环对List进行遍历删除，但删除之后马上就跳出的就不会出现异常
     * 但这种方式在需要删除多个元素的情况下无法满足要求
     */
    public static void forEachBreakRemove() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "Student" + i));
        }

        for (Student student : list) {
            if (student.getId() % CONDITION_NUM == 0) {
                list.remove(student);
                break;
            }
        }
    }

    /**
     * 一般的for循环遍历有可能会遗漏某个元素，因为删除元素后List的size在变化，元素的索引也在变化
     * 比如你循环到第2个元素的时候你把它删了，接下来你去访问第3个元素，实际上访问到的是原先的第4个元素
     * 当访问的元素索引超过了当前的List的size后还会出现数组越界的异常，当然这里不会出现这种异常
     * 因为这里每遍历一次都重新获取一次当前List的size
     */
    public static void forRemove() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "Student" + i));
        }

        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).getId() % CONDITION_NUM == 0) {
                list.remove(i);
            }
        }
    }

    /**
     * 手动处理一般的for循环遍历时删除而导致的索引变化就可以安全地删除
     */
    public static void forRemoveNoSkipping() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "Student" + i));
        }

        long millionSeconds = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).getId() % CONDITION_NUM == 0) {
                list.remove(i);
                // 删除某个元素会导致list的size减1，手动使遍历位置后移一个位置
                // 这样就不会漏掉被删除元素后面的元素
                i--;
            }
        }
        System.out.println("forRemoveNoSkipping操作耗时：" + (System.currentTimeMillis() - millionSeconds));
    }

    /**
     * 使用反向的for循环遍历时删除就无需手动处理索引变化的问题
     * 而且因为删除操作而导致的元素移动也比正向遍历要少
     */
    public static void forReverseRemoveNoSkipping() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "Student" + i));
        }

        long millionSeconds = System.currentTimeMillis();
        for (int i = list.size() - 1; i >= 0; i--) {
            if (list.get(i).getId() % CONDITION_NUM == 0) {
                list.remove(i);
            }
        }
        System.out.println("forReverseRemoveNoSkipping操作耗时：" + (System.currentTimeMillis() - millionSeconds));
    }

    /**
     * 使用Iterator的方式也可以顺利删除和遍历，不会有任何问题，这才是删除变量List中元素的正确方式
     */
    public static void iteratorRemove() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "Student" + i));
        }

        Iterator<Student> iterator = list.iterator();
        long millionSeconds = System.currentTimeMillis();
        while (iterator.hasNext()) {
            Student student = iterator.next();
            if (student.getId() % CONDITION_NUM == 0) {
                iterator.remove();
            }
        }
        System.out.println("iteratorRemove操作耗时：" + (System.currentTimeMillis() - millionSeconds));
    }

    /**
     * 也可以使用Java 8新增的removeIf方法在遍历时删除List中的元素，该方法也使用Iterator了，所以删除是安全的
     */
    public static void ifRemove() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "Student" + i));
        }

        long millionSeconds = System.currentTimeMillis();
        list.removeIf(student -> student.getId() % CONDITION_NUM == 0);
        System.out.println("ifRemove操作耗时：" + (System.currentTimeMillis() - millionSeconds));
    }

    /**
     * 使用Java 8提供的流式API来筛选元素和转换成集合类型
     * 从Java 8开始，使用流式API遍历集合是首选的方式，这种方式用于遍历非常快
     * 但由于创建了流，这种方式增大了空间开销
     */
    public static void streamRemove() {
        List<Student> list = new ArrayList<>();
        for (int i = 1; i <= LIST_SIZE; i++) {
            list.add(new Student(i, "Student" + i));
        }

        long millionSeconds = System.currentTimeMillis();
        list.stream()
                .filter(student -> student.getId() % CONDITION_NUM == 0)
                .collect(Collectors.toList());
        System.out.println("streamRemove操作耗时：" + (System.currentTimeMillis() - millionSeconds));
    }
}

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

streamRemove > forReverseRemoveNoSkipping > iteratorRemove > forRemoveNoSkipping > ifRemove

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

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

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

private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

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

final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

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

public E remove(int index) {
        rangeCheck(index);
        checkForComodification();
        E result = l.remove(index+offset);
        this.modCount = l.modCount;
        size--;
        return result;
    }

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

删除集合元素时。for-each循环使用隐藏了迭代器，所以遍历删除失败。
并行迭代多个集合对象时。

最后编辑于：2017.12.07 01:09:04

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 206,311评论 6赞 481
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 88,339评论 2赞 382
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 152,671评论 0赞 342
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 55,252评论 1赞 279
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 64,253评论 5赞 371
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,031评论 1赞 285
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,340评论 3赞 399
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,973评论 0赞 259
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,466评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,937评论 2赞 323
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,039评论 1赞 333
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,701评论 4赞 323
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,254评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,259评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,485评论 1赞 262
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,497评论 2赞 354
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,786评论 2赞 345

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

遍历集合

遍历集合时动态删除集合中的元素

推荐阅读更多精彩内容