Java在for循环中修改集合

java_t_t

已于 2024-07-23 00:34:02 修改

阅读量1k

点赞数 24

分类专栏： JAVA 文章标签： java 开发语言迭代器 for循环 for

于 2024-07-21 18:17:32 首次发布

本文链接：https://blog.youkuaiyun.com/java_t_t/article/details/140591571

版权

JAVA 专栏收录该内容

62 篇文章

订阅专栏

前天看到一篇文章什么？for循环也会出问题？，里面涉及到在for循环中修改集合，想起来自己刚入行的时候就碰到过类似的问题，于是复现了一下文章中的问题，并试验了其它在循环中修改集合的方法。

底层原理参考什么？for循环也会出问题？这篇文章的分析

1. 在fori中修改集合

在fori中修改集合，不会抛出异常
在fori中移除元素，部分元素可能会被跳过，无法被遍历到
在fori中添加元素，遍历时元素不会被跳过，但如果添加的元素恰好满足添加元素的条件，可能导致无限循环

代码如下：

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

public class TestFor {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println("*****遍历时移除元素*****");
        for (int index = 0; index < list.size(); index++) {
            Integer num = list.get(index);
            System.out.println("当前遍历：" + num);
            if (num % 2 == 0) {
                list.remove(num);
                System.out.println("移除：" + num);
            }
        }
        list.forEach(o -> System.out.print(o + "\t"));

        System.out.println();
        list.clear();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println("*****遍历时添加元素*****");
        for (int index = 0; index < list.size(); index++) {
            Integer num = list.get(index);
            System.out.println("当前遍历：" + num);
            if (num % 2 == 0) {
                int addNum = 101 + num; // 让添加进去的addNum为奇数，防止后面都是偶数，导致无限循环
                list.add(addNum);
                System.out.println("添加：" + addNum);
            }
        }
        list.forEach(o -> System.out.print(o + "\t"));
    }
}

运行结果：

*****遍历时移除元素*****
当前遍历：1
当前遍历：2
移除：2
当前遍历：4
移除：4
1    3    5
*****遍历时添加元素*****
当前遍历：1
当前遍历：2
添加：103
当前遍历：3
当前遍历：4
添加：105
当前遍历：5
当前遍历：103
当前遍历：105
1    2    3    4    5    103    105

2. 在迭代器iterator中修改集合

在iterator中通过iterator修改集合（remove），不会抛出异常
在iterator中移除元素，元素不会被跳过，但iterator.remove()前，必须先执行iterator.next()，将next element的索引+1，否则会出现IllegalStateException
使用iterator遍历元素时，跳过iterator直接去修改list，只要修改后再次执行iterator.next()，都会出现ConcurrentModificationException
使用iterator遍历元素时，即便在最后一次遍历中（此时iterator.hasNext()为false）才执行list.add()或list.remove()，也会导致iterator.hasNext()从false变为true

代码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class TestFor {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println("*****遍历时移除元素*****");
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            // iterator.remove()前，必须先执行iterator.next()，将next element的索引+1，否则会出现IllegalStateException
            Integer num = iterator.next();
            System.out.println("当前遍历：" + num);
            if (num % 2 == 0) {
                iterator.remove();
                System.out.println("移除：" + num);
            }
        }
        list.forEach(o -> System.out.print(o + "\t"));

        System.out.println();
        list.clear();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println("*****遍历时修改list，修改后不执行iterator.next()*****");
        iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer num = iterator.next();
            System.out.println("当前遍历：" + num);
            if (num == 5) {
                // list.add()、list.remove()都会导致iterator.hasNext()从false变为true
                Collections.sort(list);
                System.out.println("===>排序");
            }
        }
        list.forEach(o -> System.out.print(o + "\t"));
        System.out.println();
        list.clear();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println("*****遍历时修改list，修改后执行iterator.next()*****");
        iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer num = iterator.next();
            System.out.println("当前遍历：" + num);
            if (num == 3) {
                Collections.sort(list);
                System.out.println("===>排序");
            }
        }
        list.forEach(o -> System.out.print(o + "\t"));
    }
}

运行结果：

*****遍历时移除元素*****
当前遍历：1
当前遍历：2
移除：2
当前遍历：3
当前遍历：4
移除：4
当前遍历：5
1    3    5
*****遍历时修改list，修改后不执行iterator.next()*****
当前遍历：1
当前遍历：2
当前遍历：3
当前遍历：4
当前遍历：5
===>排序
1    2    3    4    5
*****遍历时修改list，修改后执行iterator.next()*****
当前遍历：1
当前遍历：2
当前遍历：3
===>排序
Exception in thread "main" java.util.ConcurrentModificationException
    at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1013)
    at java.base/java.util.ArrayList$Itr.next(ArrayList.java:967)
    at http.TestFor.main(TestFor.java:56)

3. 在foreach中修改集合

查看编译后的.class后可知，foreach只是迭代器iterator的语法糖，编译后也是用iterator遍历，所以跟在迭代器iterator中修改集合一样

在foreach中没有提供修改list的接口，在非最后一次遍历中修改list会出现ConcurrentModificationException
使用foreach遍历元素时，只在最后一次遍历中修改list（不执行list.add()或list.remove()，而是其它操作比如排序），不会出现ConcurrentModificationException
使用foreach遍历元素时，即便在最后一次遍历中才执行list.add()或list.remove()，也会出现ConcurrentModificationException

代码如下：

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

public class TestFor {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println("*****遍历时修改list，最后一次遍历时修改（不涉及list.add()、list.remove()）*****");
        for (Integer num : list) {
            System.out.println("当前遍历：" + num);
            if (num == 5) {
                // 查看编译后的.class后可知，foreach只是iterator的语法糖，编译后也是用iterator遍历
                // 如果在最后一次遍历中执行list.add()或list.remove()，会导致ConcurrentModificationException
                Collections.sort(list);
                System.out.println("===>排序");
            }
        }
        list.forEach(o -> System.out.print(o + "\t"));

        System.out.println();
        System.out.println("*****遍历时修改list，在非最后一次遍历时修改*****");
        for (Integer num : list) {
            System.out.println("当前遍历：" + num);
            if (num == 3) {
                Collections.sort(list);
                System.out.println("===>排序");
            }
        }
        list.forEach(o -> System.out.print(o + "\t"));
    }
}

运行结果：

*****遍历时修改list，最后一次遍历时修改（不涉及list.add()、list.remove()）*****
当前遍历：1
当前遍历：2
当前遍历：3
当前遍历：4
当前遍历：5
===>排序
1    2    3    4    5
*****遍历时修改list，在非最后一次遍历时修改*****
当前遍历：1
当前遍历：2
当前遍历：3
===>排序
Exception in thread "main" java.util.ConcurrentModificationException
    at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1013)
    at java.base/java.util.ArrayList$Itr.next(ArrayList.java:967)
    at http.TestFor.main(TestFor.java:27)