遍历同时修改 List：深入解析与实际应用

于 2024-08-28 16:00:00 发布
阅读量718 收藏 9
点赞数 17
分类专栏： Java基础 文章标签： list windows 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xycxycooo/article/details/141605612
版权

遍历同时修改 List：深入解析与实际应用

在 Java 编程中，遍历 List 的同时进行修改是一个常见的需求，但也是一个容易引发问题的操作。Java 提供了多种方式来实现这一需求，每种方式都有其优缺点和适用场景。本文将深入探讨这些方式，并通过丰富的代码示例和详细的解释，帮助你全面理解其工作原理及实际应用。

前置知识

在深入探讨之前，我们需要了解一些基本概念：

  1. List：Java 集合框架中的一种接口，用于存储有序的元素集合。
  2. 遍历：按顺序访问集合中的每个元素。
  3. 修改：在遍历过程中对集合进行添加、删除或更新操作。
  4. 并发修改异常：在遍历过程中修改集合，可能会引发 ConcurrentModificationException 异常。
方式一：使用普通 for 循环

使用普通 for 循环遍历 List，并在循环体内进行修改操作，是一种简单且直接的方式。这种方式不会引发 ConcurrentModificationException 异常，因为它是通过索引直接访问和修改元素。

示例代码
import java.util.ArrayList;
import java.util.List;

public class ForLoopExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        for (int i = 0; i < list.size(); i++) {
            String fruit = list.get(i);
            System.out.println(fruit);
            if (fruit.equals("Banana")) {
                list.remove(i);
                i--; // 调整索引，避免跳过元素
            }
        }

        System.out.println("After modification: " + list);
    }
}

输出：

Apple
Banana
Cherry
After modification: [Apple, Cherry]

解释：

  • 使用普通 for 循环遍历 List。
  • 在循环体内，通过索引访问和修改元素。
  • 删除元素后，调整索引 i--，避免跳过下一个元素。
方式二：使用增强 for 循环和临时列表

使用增强 for 循环遍历 List，并将需要修改的元素添加到临时列表中，最后统一进行修改。这种方式不会引发 ConcurrentModificationException 异常，但需要额外的存储空间。

示例代码
import java.util.ArrayList;
import java.util.List;

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

        List<String> toRemove = new ArrayList<>();
        for (String fruit : list) {
            System.out.println(fruit);
            if (fruit.equals("Banana")) {
                toRemove.add(fruit);
            }
        }

        list.removeAll(toRemove);

        System.out.println("After modification: " + list);
    }
}

输出：

Apple
Banana
Cherry
After modification: [Apple, Cherry]

解释：

  • 使用增强 for 循环遍历 List。
  • 将需要删除的元素添加到临时列表 toRemove 中。
  • 遍历结束后，调用 removeAll 方法统一删除元素。
方式三：使用 Iterator

使用 Iterator 遍历 List，并在遍历过程中使用 Iterator 的 remove 方法进行修改操作。这种方式不会引发 ConcurrentModificationException 异常，因为 Iterator 的 remove 方法是线程安全的。

示例代码
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("Apple");
        list.add("Banana");
        list.add("Cherry");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
            if (fruit.equals("Banana")) {
                iterator.remove(); // 使用 Iterator 的 remove 方法
            }
        }

        System.out.println("After modification: " + list);
    }
}

输出：

Apple
Banana
Cherry
After modification: [Apple, Cherry]

解释：

  • 使用 Iterator 遍历 List。
  • 在遍历过程中，使用 Iterator 的 remove 方法进行修改操作。
方式四：使用 Stream API

使用 Java 8 引入的 Stream API 进行遍历和修改操作。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("Apple");
        list.add("Banana");
        list.add("Cherry");

        List<String> modifiedList = list.stream()
                                        .filter(fruit -> {
                                            System.out.println(fruit);
                                            return !fruit.equals("Banana");
                                        })
                                        .collect(Collectors.toList());

        System.out.println("After modification: " + modifiedList);
    }
}

输出：

Apple
Banana
Cherry
After modification: [Apple, Cherry]

解释：

  • 使用 Stream API 遍历 List。
  • 使用 filter 方法过滤不需要的元素。
  • 使用 collect 方法将结果收集到新的列表中。
方式五：使用 CopyOnWriteArrayList

CopyOnWriteArrayList 是 Java 提供的一种线程安全的 List 实现，适用于多线程环境。它在遍历过程中不会引发 ConcurrentModificationException 异常，因为它是通过复制集合的副本来进行遍历和修改操作。

示例代码
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
            if (fruit.equals("Banana")) {
                list.remove(fruit); // 直接修改集合
            }
        }

        System.out.println("After modification: " + list);
    }
}

输出：

Apple
Banana
Cherry
After modification: [Apple, Cherry]

解释：

  • 使用 CopyOnWriteArrayList 进行遍历和修改操作。
  • 在遍历过程中，直接调用 remove 方法进行修改操作，不会引发 ConcurrentModificationException 异常。
实际应用

在实际编程中，选择合适的遍历和修改方式对于提高程序的性能和可维护性至关重要。以下是一些常见的应用场景：

  1. 单线程环境：使用普通 for 循环或 Iterator。
  2. 多线程环境：使用 CopyOnWriteArrayList。
  3. 复杂数据处理：使用 Stream API。
示例代码
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.stream.Collectors;

public class ListModificationExample {
    public static void main(String[] args) {
        // 单线程环境
        List<String> singleThreadList = new ArrayList<>();
        singleThreadList.add("Apple");
        singleThreadList.add("Banana");
        singleThreadList.add("Cherry");

        for (int i = 0; i < singleThreadList.size(); i++) {
            String fruit = singleThreadList.get(i);
            System.out.println("Single Thread: " + fruit);
            if (fruit.equals("Banana")) {
                singleThreadList.remove(i);
                i--; // 调整索引，避免跳过元素
            }
        }

        System.out.println("Single Thread After modification: " + singleThreadList);

        // 多线程环境
        CopyOnWriteArrayList<String> multiThreadList = new CopyOnWriteArrayList<>();
        multiThreadList.add("Apple");
        multiThreadList.add("Banana");
        multiThreadList.add("Cherry");

        Iterator<String> multiThreadIterator = multiThreadList.iterator();
        while (multiThreadIterator.hasNext()) {
            String fruit = multiThreadIterator.next();
            System.out.println("Multi Thread: " + fruit);
            if (fruit.equals("Banana")) {
                multiThreadList.remove(fruit); // 直接修改集合
            }
        }

        System.out.println("Multi Thread After modification: " + multiThreadList);

        // 复杂数据处理
        List<String> complexList = new ArrayList<>();
        complexList.add("Apple");
        complexList.add("Banana");
        complexList.add("Cherry");

        List<String> modifiedComplexList = complexList.stream()
                                                      .filter(fruit -> {
                                                          System.out.println("Complex: " + fruit);
                                                          return !fruit.equals("Banana");
                                                      })
                                                      .collect(Collectors.toList());

        System.out.println("Complex After modification: " + modifiedComplexList);
    }
}

输出：

Single Thread: Apple
Single Thread: Banana
Single Thread: Cherry
Single Thread After modification: [Apple, Cherry]
Multi Thread: Apple
Multi Thread: Banana
Multi Thread: Cherry
Multi Thread After modification: [Apple, Cherry]
Complex: Apple
Complex: Banana
Complex: Cherry
Complex After modification: [Apple, Cherry]

解释：

  • 在单线程环境中，使用普通 for 循环进行遍历和修改操作。
  • 在多线程环境中，使用 CopyOnWriteArrayList 进行遍历和修改操作。
  • 在复杂数据处理场景中，使用 Stream API 进行遍历和修改操作。
总结

在 Java 编程中，遍历 List 的同时进行修改是一个常见的需求，但也是一个容易引发问题的操作。Java 提供了多种方式来实现这一需求，包括使用普通 for 循环、增强 for 循环和临时列表、Iterator、Stream API 和 CopyOnWriteArrayList。理解这些方式的工作原理及实际应用，有助于编写更高效、更易于维护的代码。

希望通过本文的详细解释和代码示例，你已经对遍历同时修改 List 的几种方式有了更深入的理解。如果你有任何问题或需要进一步的解释，请随时提问！

需要重新演唱
关注
  • 17
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
深入解析 `CopyOnWriteArrayList` 的实现原理与应用
fudaihb的博客
06-27 1183
在并发编程中，线程安全是一个至关重要的问题。Java 提供了多种并发工具来确保线程安全，其中之一便是 `CopyOnWriteArrayList`。本文将详细探讨 `CopyOnWriteArrayList` 的实现原理、使用场景及其优缺点，帮助您更好地理解和应用这一数据结构。
深入解析 Python 列表与元组的操作技巧与应用场景
mrdeam的博客
06-25 922
创建和访问：展示了如何创建列表和元组，并介绍了如何通过索引访问其元素。修改和删除：对列表和元组的可变性进行了比较，说明了列表可修改而元组不可修改的特性，并展示了相应的操作方法。切片操作：介绍了列表和元组的切片操作，用于获取子集。添加和拼接：说明了如何向列表添加元素以及如何拼接多个列表或元组。迭代和长度：展示了如何对列表和元组进行迭代，并介绍了获取它们长度的方法。转换和比较：演示了列表和元组之间的转换方法，以及如何进行比较操作。解构赋值和排序：介绍了解构赋值和排序的操作方法，以及它们的应用场景。
B树：深入解析与实战应用
qq_39465480的博客
07-13 1135
B树（B-tree）是一种自平衡的树，能够保持数据稳定有序，其插入与修改拥有较平均的渐进复杂度。每个节点最多有m个子节点。除了根节点和叶子节点外，其它每个节点至少有⌈m/2⌉个子节点（其中⌈x⌉表示不小于x的最小整数）。若根节点不是叶子节点，则至少有两个子节点。所有叶子节点都在同一层上，且不带信息（可以看做是外部节点或查找失败的节点，实际上这些节点不存在，指向这些节点的指针都为空）。有k个子节点的非终端节点恰好有k-1个关键字（即子节点数比关键字数多1）。
C++学习第二十课：STL中的`list`和`forward_list`深度解析
2401_84585615的博客
05-03 442
std::list和都是顺序容器，但它们在底层实现和操作上有所不同。通过本课的学习，你全面了解了STL中的std::list和容器，包括其初始化、元素访问、大小管理、添加和移除元素、迭代器使用、内存管理、性能考量、异常安全性、特化和偏特化、实际应用、线程安全性以及未来发展。std::list和是C++中处理链表的强大工具，它们在某些场景下提供了比更高的性能和灵活性。掌握这两种容器的使用对于编写高效、安全、可维护的C++程序至关重要。
Spring EL表达式：概念、特性与应用深入解析
码到三十五
02-16 4690
在Spring框架中，Spring Expression Language（简称Spring EL）是一种功能强大的表达式语言，它支持在运行时查询和操作对象图。本文将详细介绍Spring EL表达式的概念、特点、基本语法和用法，并探讨在Spring框架中的应用场景。同时，我们还将分析Spring EL的优势和局限性，并与其他相关技术进行比较。
掌握C++中的动态数据：深入解析list的力量与灵活性
Von_016's Blog
02-08 1914
std::list的sort()方法允许传递自定义比较函数或者lambda表达式来定义排序逻辑。// 降序排序});std::list允许开发者通过提供自定义比较函数来实现复杂的排序逻辑。这在处理自定义对象或需要非标准排序顺序的场合尤为有用。例如，如果有一个包含自定义结构体的std::listint age;// 填充people...// 根据年龄升序排序});
前端文摘：深入解析浏览器的幕后工作原理
stillWaters的专栏
04-17 1690
outer table inner table 这是一篇全面介绍 Webkit 和 Gecko 内部操作的入门文章，是以色列开发人员塔利·加希尔大量研究的成果。在过去的几年中，她查阅了所有公开发布的关于浏览器内部机制的数据（请参见资源），并花了很多时间来研读网络浏览器的源代码。她写道： 在 IE 占据 90% 市场份额的年代，我们除了把浏览器当成一个“黑箱”，什么也做不了。但是现
深入解析双向链表与单向链表的区别：示例详解
qq_35320456的博客
07-14 879
深入解析双向链表与单向链表的区别：示例详解。。 链表是一种灵活的数据结构，它通过指针连接一系列节点，实现了动态数组的特性。在众多链表类型中，单向链表和双向链表是最为常见的两种。本文将重点探讨这两种链表的区别，并通过示例进行详细说明。
【数据结构与算法】之深入解析“二叉树的层序遍历”的求解思路与算法示例
╰つ栺尖篴夢ゞ
02-16 611
一、题目要求 给你二叉树的根节点 root ，返回其节点值的层序遍历 （即逐层地，从左到右访问所有节点）。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[15,7]] 示例 2： 输入：root = [1] 输出：[[1]] 示例 3： 输入：root = [] 输出：[] 提示： 树中节点数目在范围 [0, 2000] 内； -1000 <= Node.val <= 1000。 二、求解算
Python魔法参数：深入解析*args和**kwargs的强大用途
xyh2004的博客
06-27 909
*args和**kwargs是Python中的可变参数，它们允许你在函数中传递未命名的变量数量。*args用于无键值的可变数量参数，使得函数可以接受任何数量的位置参数；**kwargs允许函数接受任意数量的关键字参数。这种参数的使用打开了Python编程的新视界，从简单的函数重载到复杂的函数装饰器和动态API调用处理，应用范围极广。
深入浅出带你学Python：深入解析Python基础语法
# 1. Python入门 ## 1.1 Python简介 Python是一种高级、通用、直译式编程语言。由Guido van Rossum于1989年在荷兰设计并发展，第一个公开发行版...## 1.2 Python安装与环境搭建 要开始学习Python编程，首先需要在计
同鑫T9eHR信息华管理系统GetDropDownListItems存在SQL注入漏洞
最新发布
2301_77012231的博客
08-27 137
广州同鑫科技有限公司是专业从事人力资源管理系统、eHR/OA一体化智慧云平台、智慧一卡通云平台、行业软件开发与定制、智慧企业管理信息化咨询与项目服务为核心业务的顾问式管理咨询和软件个性定制开发的高科技股份集团公司。广州同鑫科技有限公司同鑫T9eHR信息华管理系统GetDropDownListItems存在SQL注入漏洞，攻击者可通过该漏洞获取数据库敏感信息。
Java-List结合ComableFuture自定义线程池的工具类
兴趣是最好的老师
08-26 185
为了结合 CompletableFuture 处理列表中的数据，并利用自定义线程池来并行处理这些元素，我们。假设我们有一个整数列表，并希望将每个整数转换为其平方值，同时利用自定义线程池来加速处理。假设我们有一个整数列表，并希望将每个整数转换为其平方值，同时利用自定义线程池来加速处理。这个扩展版本的工具类提供了更全面的功能，包括超时控制和异常处理，使得在处理大规模数据集。该方法接收一个列表、一个处理每个元素的函数以及一个自定义线程池，并利用。列表 squaredNumbers，其中包含了转换后的整数。
C++笔记9•list•
qq_64446190的博客
08-27 208
容器之list
4. Java中的ArrayList和LinkedList有什么区别？各自的优缺点是什么？在什么场景下选择使用它们？
zhzjn的博客
08-24 968
ArrayList优点：随机访问快，适合频繁的读取操作。内存使用效率较高，相对于LinkedList节省空间（没有额外的指针开销）。在数组末尾添加元素的操作效率高。ArrayList缺点：在中间或开头插入和删除元素效率较低，涉及到大量元素的移动。扩容时可能会产生性能开销（需要复制数组）。LinkedList优点：插入和删除元素效率高，尤其是在列表的头部或中部（前提是已定位到节点）。不需要预分配空间，内存利用率高。LinkedList缺点：随机访问慢，不适合频繁的读取操作。相对于。
list底层详解
2301_80418172的博客
08-27 615
STL之list底层详解
List＜对象＞转JSON字符串以及JSON字符串转List＜对象＞
YangCunle的博客
08-22 464
记录一下List转JSON字符串以及JSON字符串转List博客主要记录了List转JSON字符串以及JSON字符串转List，有啥错误或不足地方请指正，如果对你有所帮助，请一键三连。
关于Arrays.asList返回List无法新增和删除？
sdgfafg_25的博客
08-22 494
也就是说我们可以调用get方法得到Arrays.asList返回的集合元素，也可以set修改这里面的值，但是因为它没有add和remove方法所以无法对集合进行增加和删除，这也是为什么会报错：UnsupportedOperationException（没有支持的方法）的原因。因为这里返回的是一个 final 数组，数组本身就是不可变的，所以当调用Arrays.asList方法返回一个集合后，无法在对这个集合进行一些操作，这个是数组的特性。这个是在写项目的时候发现的，然后就分析了一下源码，得其内部原理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

需要重新演唱

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值