1. 问题背景与核心思考
作为一名Java开发者，我经常遇到这样的场景：在遍历数组或集合时，需要根据某些条件动态修改它们的内容。最初，我以为数组和集合在循环中的表现应该是一致的，直到某次线上事故让我彻底改变了这个认知。
那是一个普通的周二下午，我正在处理一个用户数据过滤的功能。代码逻辑很简单：遍历ArrayList，删除不符合条件的元素。我使用了最常规的for循环：
java复制for (int i = 0; i < list.size(); i++) {
if (shouldRemove(list.get(i))) {
list.remove(i);
}
}
结果发现，有些应该被删除的元素居然留在了集合里！更糟糕的是，当连续两个元素都需要删除时，程序直接抛出了IndexOutOfBoundsException。这次经历让我深刻认识到：在Java中循环修改集合长度是个需要特别小心的问题。
2. 数组与集合的本质区别
2.1 数组的固定长度特性
Java数组有一个非常重要的特性：长度不可变。当我们声明一个数组时：
java复制int[] arr = new int[5];
这个数组的长度就被固定为5，无法改变。即使我们尝试给arr重新赋值：
java复制arr = new int[10];
这实际上是创建了一个全新的数组对象，而不是修改原数组的长度。
在循环中使用数组时，这个特性带来了一个关键优势：循环条件判断中的array.length值在循环开始时就确定了，不会因为循环体内的操作而改变。看下面这个例子：
java复制int[] nums = {1, 2, 3};
for (int i = 0; i < nums.length; i++) {
System.out.println(nums[i]);
nums = new int[]{4, 5, 6, 7}; // 创建新数组
}
尽管我们在循环内给nums赋了新值，但循环仍然只执行3次，因为最初的nums.length是3，这个值在循环开始时就已经确定了。
2.2 集合的动态长度特性
与数组不同，Java集合（如ArrayList）的长度是动态的。当我们调用list.add()或list.remove()时，集合的size()会实时变化。这个特性虽然提供了灵活性，但在循环中却可能带来问题。
考虑以下代码：
java复制List<String> colors = new ArrayList<>(Arrays.asList("红", "绿", "蓝"));
for (int i = 0; i < colors.size(); i++) {
if (colors.get(i).equals("绿")) {
colors.remove(i);
}
}
执行后，colors的内容会是["红", "蓝"]，看起来似乎没问题。但如果初始列表是["红", "绿", "绿", "蓝"]呢？
第一次删除"绿"（索引1）后，列表变为["红", "绿", "蓝"]，此时i递增到2，直接跳过了第二个"绿"，最终结果是["红", "绿", "蓝"]，这显然不是我们想要的结果。
3. 安全修改集合的几种方式
3.1 使用迭代器（Iterator）
迭代器是Java专门为集合遍历设计的接口，它提供了安全的元素移除方式：
java复制List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
Integer num = it.next();
if (num % 2 == 0) {
it.remove(); // 安全移除当前元素
}
}
注意：必须在调用next()之后才能调用remove()，且每次next()后只能调用一次remove()。
迭代器的优势在于：
- 内部维护了遍历状态，不受集合修改影响
- 提供了统一的遍历接口
- 是线程安全的（在单线程环境下）
3.2 倒序遍历
对于简单的删除操作，倒序遍历是个不错的选择：
java复制List<String> fruits = new ArrayList<>(Arrays.asList("苹果", "香蕉", "橙子"));
for (int i = fruits.size() - 1; i >= 0; i--) {
if (fruits.get(i).contains("香")) {
fruits.remove(i);
}
}
倒序遍历的优点：
- 删除元素不会影响未遍历的索引
- 代码直观，容易理解
- 不需要创建额外对象（如迭代器）
3.3 遍历副本，修改原集合
当需要同时进行添加和删除操作时，可以考虑遍历集合的副本：
java复制List<String> original = new ArrayList<>(Arrays.asList("A", "B", "C"));
for (String item : new ArrayList<>(original)) {
if (item.equals("B")) {
original.remove(item);
original.add("D");
}
}
这种方式虽然会消耗一些额外内存（创建副本），但在复杂逻辑下能保证遍历的稳定性。
4. 性能对比与选择建议
4.1 各种方式的性能特点
| 方式 | 时间复杂度 | 空间复杂度 | 适用场景 |
|---|---|---|---|
| 普通for循环 | O(n) | O(1) | 只读遍历 |
| 迭代器 | O(n) | O(1) | 需要删除元素 |
| 倒序遍历 | O(n) | O(1) | 简单删除操作 |
| 遍历副本 | O(n) | O(n) | 需要同时增删元素 |
4.2 实际开发中的选择建议
-
只读遍历：优先使用增强for循环（for-each），语法简洁：
java复制for (String item : collection) { System.out.println(item); } -
需要删除元素：
- 如果逻辑简单，使用倒序遍历
- 如果逻辑复杂，使用迭代器
-
需要添加元素：
- 少量添加可以使用ListIterator：
java复制ListIterator<String> it = list.listIterator(); while (it.hasNext()) { if (it.next().equals("标记")) { it.add("新元素"); } } - 大量修改建议先收集要添加的元素，最后统一addAll
- 少量添加可以使用ListIterator：
-
并发环境：
- 使用CopyOnWriteArrayList等线程安全集合
- 或者显式加锁
5. 常见陷阱与解决方案
5.1 ConcurrentModificationException
这个异常是很多Java开发者都遇到过的"老朋友"。它发生在使用迭代器遍历时，集合被直接修改（而非通过迭代器修改）：
java复制List<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3));
for (Integer num : nums) {
if (num == 2) {
nums.remove(num); // 抛出ConcurrentModificationException
}
}
解决方案：
- 使用迭代器的remove()方法
- 使用CopyOnWriteArrayList（适合读多写少场景）
- 使用传统的for循环并注意索引处理
5.2 索引越界问题
在正序遍历删除元素时，很容易出现索引越界：
java复制List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
for (int i = 0; i < list.size(); i++) {
list.remove(i); // 当i=1时，size=1，下次i=2会越界
}
解决方案：
- 每次删除后i--：
java复制for (int i = 0; i < list.size(); i++) { list.remove(i); i--; // 补偿索引变化 } - 改用倒序遍历
5.3 性能陷阱
有些看似聪明的解决方案实际上性能很差：
-
频繁创建副本：
java复制while (!list.isEmpty()) { List temp = new ArrayList(list); // 处理temp list.removeAll(/*某些条件*/); } -
在循环中调用size()：
java复制for (int i = 0; i < list.size(); i++) { // size()可能每次都要计算 // ... }改进：
java复制int size = list.size(); for (int i = 0; i < size; i++) { // ... }
6. Java 8+的现代解决方案
6.1 使用Stream API
Java 8引入的Stream提供了一种更函数式的处理方式：
java复制List<String> filtered = list.stream()
.filter(s -> !s.isEmpty())
.collect(Collectors.toList());
优点：
- 代码简洁
- 易于并行化
- 无副作用
缺点：
- 不能直接修改原集合
- 创建新集合有内存开销
6.2 removeIf方法
Java 8为Collection添加了removeIf方法：
java复制list.removeIf(s -> s.contains("test"));
内部实现使用了迭代器，是线程不安全的，但在单线程下非常高效。
6.3 并行流处理
对于大数据集，可以考虑并行流：
java复制List<String> result = largeList.parallelStream()
.filter(this::complexFilter)
.collect(Collectors.toList());
但要注意：
- 确保filter操作是线程安全的
- 小数据集可能适得其反
7. 实际项目经验分享
在电商系统开发中，我遇到过这样一个需求：处理用户购物车，删除无库存的商品，同时合并相同商品的数量。最初实现是这样的：
java复制for (int i = 0; i < cartItems.size(); i++) {
CartItem item = cartItems.get(i);
if (item.getStock() == 0) {
cartItems.remove(i);
i--;
continue;
}
for (int j = i + 1; j < cartItems.size(); j++) {
if (item.equals(cartItems.get(j))) {
item.addQuantity(cartItems.get(j).getQuantity());
cartItems.remove(j);
j--;
}
}
}
这段代码虽然能用，但存在几个问题：
- 嵌套循环+索引调整，逻辑复杂
- 性能随购物车大小呈平方级增长
- 容易引入bug
重构后使用迭代器：
java复制Iterator<CartItem> iterator = cartItems.iterator();
while (iterator.hasNext()) {
CartItem item = iterator.next();
if (item.getStock() == 0) {
iterator.remove();
continue;
}
// 使用Stream处理合并
int total = cartItems.stream()
.filter(i -> i.equals(item))
.mapToInt(CartItem::getQuantity)
.sum();
item.setQuantity(total);
// 移除重复项
cartItems.removeIf(i -> i.equals(item) && i != item);
}
重构后的代码：
- 逻辑更清晰
- 使用Stream简化合并操作
- 性能更好（虽然仍有优化空间）
8. 扩展思考：其他集合类型的处理
8.1 Set集合
Set通常使用迭代器遍历，因为大多数Set实现没有索引概念。注意：
- HashSet的迭代顺序不确定
- 使用iterator.remove()是安全的
- 添加元素可能改变整个Set的结构
8.2 Map集合
遍历Map时修改需要特别注意：
java复制Map<String, Integer> map = new HashMap<>();
// 安全删除
map.entrySet().removeIf(entry -> entry.getValue() < 0);
// Java 8+的compute方法
map.compute("key", (k, v) -> v == null ? 1 : v + 1);
8.3 并发集合
对于ConcurrentHashMap等并发集合：
- 迭代器是弱一致性的
- 可以使用forEach并行处理
- 原子操作方法更安全
9. 最佳实践总结
经过多年Java开发，我总结了以下最佳实践：
-
基本原则：
- 遍历时不修改集合是首选方案
- 如果必须修改，选择合适的方式
- 考虑线程安全性需求
-
代码可读性：
- 优先使用Java 8+的新API
- 给复杂操作添加注释
- 提取方法保持代码简洁
-
性能考量：
- 大数据集考虑并行处理
- 避免在循环中创建临时集合
- 预分配集合大小（如new ArrayList<>(expectedSize)）
-
测试建议：
- 特别测试边界条件（空集合、单元素集合等）
- 对并发修改场景增加压力测试
- 监控实际运行时的集合操作性能
最后提醒一点：在Java中，集合操作看似简单，但魔鬼藏在细节里。每次写遍历+修改的代码时，都应该停下来思考一下：这种方式是否安全？是否有更好的选择？性能是否可接受？多花几分钟思考这些问题，可以避免很多潜在的问题。