在遍历过程中修改 List 的几种方式

引言

在 Java 中，遍历集合（如 List）时直接修改集合元素通常是安全的，但如果尝试在遍历过程中添加或删除元素，则可能导致 ConcurrentModificationException 异常。本文将探讨如何安全地在遍历过程中修改 List，包括添加和删除元素。

安全地修改 List

在遍历过程中修改 List 主要有以下几种安全的方法：

1. 使用迭代器
2. 使用增强 for 循环结合临时变量
3. 使用流（Stream API）
4. 使用循环索引

使用迭代器

使用迭代器可以安全地删除元素，但不能添加元素。

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

public class IteratorExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if ("two".equals(item)) {
                iterator.remove();  // 安全地删除元素
            }
        }

        System.out.println(list);  // 输出: [one, three]
    }
}

使用增强 for 循环结合临时变量

这种方式适合添加元素，但不适合删除元素。

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

public class EnhancedForLoopExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");

        for (String item : list) {
            list.add("four");  // 不推荐，容易引发 ConcurrentModificationException
        }

        List<String> temp = new ArrayList<>();
        for (String item : list) {
            temp.add(item + "-modified");
        }

        list.clear();
        list.addAll(temp);

        System.out.println(list);  // 输出: [one-modified, two-modified, three-modified, four-modified, four-modified, four-modified]
    }
}

使用流（Stream API）

使用 Java 8 及以上的 Stream API 可以简洁地实现修改操作。

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");

        List<String> modifiedList = list.stream()
                                         .map(s -> s + "-modified")
                                         .collect(Collectors.toList());

        list.clear();
        list.addAll(modifiedList);

        System.out.println(list);  // 输出: [one-modified, two-modified, three-modified]
    }
}

使用循环索引

使用传统的 for 循环和索引可以安全地在遍历过程中添加或删除元素。

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

public class ForIndexExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");

        // 删除元素
        for (int i = 0; i < list.size(); ) {
            String item = list.get(i);
            if ("two".equals(item)) {
                list.remove(i);
            } else {
                i++;
            }
        }

        // 添加元素
        for (int i = 0; i < list.size(); i++) {
            list.add(i, "zero");
        }

        System.out.println(list);  // 输出: [zero, one, zero, three]
    }
}

总结

• 使用迭代器：最安全的方式之一，特别适合删除元素。
• 使用增强 for 循环结合临时变量：适用于修改元素而不改变列表大小的情况。
• 使用流（Stream API）：现代 Java 开发者的首选，尤其适用于 Java 8 及以上版本。
• 使用循环索引：传统方式，适用于需要同时添加和删除元素的情况。

参考资料

• Java Tutorials: Collections
• Java Streams API
• Java Concurrency in Practice

以上示例展示了不同情况下如何安全地在遍历过程中修改 List。在实际应用中，建议优先选择使用迭代器或 Stream API，这些方法更为简洁且易于理解。