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

弁言

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

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

• 利用迭代器
  
• 利用加强 for 循环结合临时变量
  
• 利用流（Stream API）
  
• 利用循环索引
  

利用迭代器

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

1. import java.util.ArrayList;
2. import java.util.Iterator;
3. import java.util.List;
5. public class IteratorExample {
6.     public static void main(String[] args) {
7.         List<String> list = new ArrayList<>();
8.         list.add("one");
9.         list.add("two");
10.         list.add("three");
12.         Iterator<String> iterator = list.iterator();
13.         while (iterator.hasNext()) {
14.             String item = iterator.next();
15.             if ("two".equals(item)) {
16.                 iterator.remove();  // 安全地删除元素
17.             }
18.         }
20.         System.out.println(list);  // 输出: [one, three]
21.     }
22. }

复制代码

利用加强 for 循环结合临时变量

这种方式得当添加元素，但不得当删除元素。

1. import java.util.ArrayList;
2. import java.util.List;
4. public class EnhancedForLoopExample {
5.     public static void main(String[] args) {
6.         List<String> list = new ArrayList<>();
7.         list.add("one");
8.         list.add("two");
9.         list.add("three");
11.         for (String item : list) {
12.             list.add("four");  // 不推荐，容易引发 ConcurrentModificationException
13.         }
15.         List<String> temp = new ArrayList<>();
16.         for (String item : list) {
17.             temp.add(item + "-modified");
18.         }
20.         list.clear();
21.         list.addAll(temp);
23.         System.out.println(list);  // 输出: [one-modified, two-modified, three-modified, four-modified, four-modified, four-modified]
24.     }
25. }

复制代码

利用流（Stream API）

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

1. import java.util.ArrayList;
2. import java.util.List;
3. import java.util.stream.Collectors;
5. public class StreamExample {
6.     public static void main(String[] args) {
7.         List<String> list = new ArrayList<>();
8.         list.add("one");
9.         list.add("two");
10.         list.add("three");
12.         List<String> modifiedList = list.stream()
13.                                          .map(s -> s + "-modified")
14.                                          .collect(Collectors.toList());
16.         list.clear();
17.         list.addAll(modifiedList);
19.         System.out.println(list);  // 输出: [one-modified, two-modified, three-modified]
20.     }
21. }

复制代码

利用循环索引

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

1. import java.util.ArrayList;
2. import java.util.List;
4. public class ForIndexExample {
5.     public static void main(String[] args) {
6.         List<String> list = new ArrayList<>();
7.         list.add("one");
8.         list.add("two");
9.         list.add("three");
11.         // 删除元素
12.         for (int i = 0; i < list.size(); ) {
13.             String item = list.get(i);
14.             if ("two".equals(item)) {
15.                 list.remove(i);
16.             } else {
17.                 i++;
18.             }
19.         }
21.         // 添加元素
22.         for (int i = 0; i < list.size(); i++) {
23.             list.add(i, "zero");
24.         }
26.         System.out.println(list);  // 输出: [zero, one, zero, three]
27.     }
28. }

复制代码

总结

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

参考资料

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

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。