Java集合遍历四方法全解析
Java集合遍历是编程中常见的操作,本文深入解析四种主流方法,助你高效处理数据。**增强for循环**简洁易用,适合只读遍历;**迭代器**则能在遍历时安全删除元素,避免并发问题;**传统for循环**凭借索引优势,方便访问List集合;而**Java 8 Stream API**则以函数式编程风格,简化复杂的数据处理流程,支持过滤、映射、排序等操作,甚至能进行并行计算。选择哪种遍历方式,需根据实际需求,权衡代码可读性与性能,找到最合适的解决方案。
遍历Java集合元素主要有以下几种方法:1. 增强for循环适用于只读遍历,代码简洁;2. 迭代器适用于遍历中需安全删除元素的场景;3. 传统for循环适用于需索引访问的List集合;4. Java 8 Stream API适用于复杂数据处理,支持函数式编程和并行操作。选择应根据具体需求如是否需修改集合、是否依赖索引或追求代码可读性而定,最终方案完整且有效。
在Java里,遍历集合元素其实有那么几条路子可以走,每条路都有它自己的脾气和适用场景。简单来说,最常见也最直观的就是用增强for循环(也就是我们常说的for-each),它用起来特别顺手。如果需要更精细的控制,比如在遍历的时候删除元素,那迭代器(Iterator)就派上用场了。对于有索引的列表,传统的for循环也依然能打。当然,到了Java 8时代,Stream API又提供了一种更函数式、更简洁的遍历和操作方式。
解决方案
遍历Java集合元素,主要有以下几种常用且各有侧重的方法。选择哪种,往往取决于你的具体需求和对代码可读性的偏好。
1. 增强for循环 (For-each Loop) 这是最简洁、最常用的方式,特别适合只需要遍历集合元素而不需要知道其索引,也不需要在遍历过程中修改(删除)集合的情况。它隐藏了迭代器的复杂性,让代码看起来更干净。
import java.util.ArrayList; import java.util.List; public class CollectionIterationExample { public static void main(String[] args) { List<String> names = new ArrayList<>(); names.add("Alice"); names.add("Bob"); names.add("Charlie"); System.out.println("--- 增强for循环 ---"); for (String name : names) { System.out.println("你好, " + name); } } }
2. 迭代器 (Iterator)
当你需要在遍历集合的同时,安全地删除某些元素时,迭代器是你的不二之选。增强for循环在底层其实也是通过迭代器实现的,但它没有暴露remove()
方法,直接在增强for循环里尝试修改集合会抛出ConcurrentModificationException
。
import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class CollectionIterationExample { public static void main(String[] args) { List<String> numbers = new ArrayList<>(); numbers.add("One"); numbers.add("Two"); numbers.add("Three"); numbers.add("Four"); System.out.println("\n--- 迭代器循环 ---"); Iterator<String> it = numbers.iterator(); while (it.hasNext()) { String num = it.next(); System.out.println("当前元素: " + num); if ("Two".equals(num)) { it.remove(); // 安全删除元素 System.out.println("删除了 'Two'"); } } System.out.println("删除后的集合: " + numbers); } }
3. 传统for循环 (Indexed For Loop)
这种方式主要适用于List
接口的实现类(如ArrayList
、Vector
),因为它们支持通过索引来访问元素。当你需要根据元素的索引进行操作,或者需要反向遍历时,传统for循环会比较方便。
import java.util.ArrayList; import java.util.List; public class CollectionIterationExample { public static void main(String[] args) { List<Integer> scores = new ArrayList<>(); scores.add(90); scores.add(85); scores.add(92); System.out.println("\n--- 传统for循环 ---"); for (int i = 0; i < scores.size(); i++) { System.out.println("索引 " + i + " 的分数: " + scores.get(i)); } } }
4. Java 8 Stream API Java 8引入的Stream API提供了一种更声明式、更函数式的处理集合数据的方式。它不仅可以遍历,还能进行过滤、映射、排序等一系列操作,链式调用让代码逻辑非常清晰,而且内部支持并行处理。
import java.util.Arrays; import java.util.List; public class CollectionIterationExample { public static void main(String[] args) { List<String> cities = Arrays.asList("London", "Paris", "New York", "Tokyo"); System.out.println("\n--- Java 8 Stream API ---"); cities.stream() .filter(city -> city.startsWith("N")) // 过滤 .map(String::toUpperCase) // 转换 .forEach(System.out::println); // 遍历并打印 } }
迭代器和增强for循环,到底用哪个?
这问题挺有意思的,我个人觉得,这两种遍历方式就像是工具箱里的两把锤子,各有各的顺手之处。
增强for循环(for-each)无疑是现代Java开发者的首选,因为它写起来真的太舒服了,代码简洁明了,可读性极高。你不需要关心索引,也不用手动获取迭代器,直接for (ElementType element : collection)
,就完事了。对于大多数只读遍历的场景,它简直是完美。比如,你只是想把列表里的名字都打印出来,或者计算一下所有数字的总和,用它准没错。它在底层其实就是个语法糖,编译器会把它转换成使用迭代器的形式。
但是,一旦你的需求稍微复杂一点,比如你需要在遍历集合的时候,根据某个条件把一些元素从集合里“踢出去”,这时候增强for循环就会让你头疼。如果你在for-each循环体里直接调用集合的remove()
方法,恭喜你,你会遇到一个经典的ConcurrentModificationException
。这是因为for-each循环在遍历时会检查集合的修改状态,一旦发现集合被“非法”修改(即不是通过迭代器自身的remove()
方法修改),它就会抛出这个异常,防止你遇到一些意想不到的并发问题。
这时候,迭代器(Iterator)就显得不可替代了。它提供了一个remove()
方法,允许你在遍历过程中安全地删除当前元素。当你需要边遍历边修改集合结构时,比如清理一个列表中的无效项,或者从一个集合中移除所有符合特定条件的元素,使用迭代器才是正确且安全的做法。虽然代码会比for-each稍微多写几行,但为了安全和功能,这点付出是值得的。
简单来说:
- 只读遍历、代码简洁至上:选增强for循环。
- 遍历时需要安全修改(删除)集合元素:选迭代器。
多线程环境下遍历集合,一不小心就踩坑?
确实,在多线程环境下操作集合,尤其是遍历,是个非常容易“踩坑”的地方。最常见的坑就是前面提到的ConcurrentModificationException
,它不仅仅发生在单线程里for-each循环中修改集合,在多线程环境下,如果一个线程正在遍历集合,而另一个线程同时对集合进行了结构性修改(添加、删除元素),这个异常几乎是必然会发生的。这就像你正在看一本书,别人突然把书的几页撕掉了或者加了几页,你肯定会懵圈。
那么,怎么避免呢?
使用同步包装器(Synchronized Wrappers):Java的
Collections
工具类提供了一些静态方法,可以将非线程安全的集合包装成线程安全的,比如Collections.synchronizedList()
、Collections.synchronizedMap()
。这些方法返回的集合,其所有方法(包括迭代)都会被同步,确保同一时间只有一个线程能访问集合。List<String> syncList = Collections.synchronizedList(new ArrayList<>()); // 在遍历时,你仍然需要手动同步迭代器,这常常被忽略 synchronized (syncList) { for (String item : syncList) { System.out.println(item); } }
但这种方式有个隐患,就是虽然集合操作是同步的,但迭代器本身并不是。所以,即使你用了
synchronizedList
,在遍历时,你仍然需要手动对集合对象进行同步锁定,否则依然可能遇到ConcurrentModificationException
。这有点反直觉,也容易出错。使用并发集合类(Concurrent Collections):这是Java并发包
java.util.concurrent
提供的解决方案,它们从设计之初就考虑了多线程环境下的性能和安全性。CopyOnWriteArrayList
/CopyOnWriteArraySet
: 它们在修改(添加、删除)时,会创建一个底层数组的副本,在新副本上进行修改,然后将引用指向新副本。这意味着读操作(包括遍历)是无锁的,非常快,因为它们总是操作一个不变的快照。缺点是写操作开销较大,且内存占用会增加。适合读多写少的场景。import java.util.concurrent.CopyOnWriteArrayList; List<String> threadSafeList = new CopyOnWriteArrayList<>(); threadSafeList.add("A"); threadSafeList.add("B"); // 遍历时不需要额外同步,即使有其他线程在修改,也会看到遍历开始时的快照 for (String item : threadSafeList) { System.out.println(item); }
ConcurrentHashMap
: 这是HashMap
的线程安全版本,性能远超HashTable
和Collections.synchronizedMap()
。它通过分段锁(Java 7及以前)或CAS操作(Java 8)来提高并发度,读操作通常不需要加锁。import java.util.concurrent.ConcurrentHashMap; import java.util.Map; Map<String, Integer> concurrentMap = new ConcurrentHashMap<>(); concurrentMap.put("key1", 1); concurrentMap.put("key2", 2); // 遍历时通常是弱一致性,即不保证看到所有最新的修改,但不会抛出ConcurrentModificationException for (Map.Entry<String, Integer> entry : concurrentMap.entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); }
外部同步(External Synchronization):如果你的集合不是并发集合,也没有通过
Collections.synchronizedXxx()
包装,那么最保险的办法就是在所有对集合的读写操作(包括遍历)外层都加上显式的同步锁。List<String> myList = new ArrayList<>(); // ... // 所有访问 myList 的代码块都需要同步 synchronized (myList) { for (String item : myList) { System.out.println(item); } }
这种方式虽然安全,但会显著降低并发性能,因为每次只有一个线程能访问集合。
选择哪种方式,取决于你的具体场景:如果读操作远多于写操作,CopyOnWriteArrayList
是个不错的选择;如果需要高性能的并发Map,ConcurrentHashMap
是标准答案;如果只是偶尔的并发访问,或者对性能要求不高,外部同步或synchronizedList
可能也够用,但要特别注意迭代器的同步问题。
Java 8 Stream API:遍历集合的新姿势?
Java 8引入的Stream API,确实给集合的遍历和操作带来了“新姿势”,它不仅仅是遍历,更是一种声明式的数据处理管道。我个人觉得,它把我们从命令式的“怎么做”拉到了声明式的“做什么”,代码写起来更像是描述业务逻辑,而不是一步步地告诉机器执行什么指令。
Stream API的核心思想是,你可以把集合看作是一个数据流,然后在这个流上进行一系列的操作,这些操作可以分为两类:
中间操作(Intermediate Operations):这些操作会返回一个新的Stream,它们是“懒惰的”,只有当终端操作被调用时才会真正执行。常见的有:
filter(Predicate)
: 过滤元素,只保留符合条件的。map(Function)
: 将元素一对一地转换成另一种类型。flatMap(Function)
: 将元素一对多地转换,并把结果扁平化成一个Stream。sorted()
: 对元素进行排序。distinct()
: 去除重复元素。limit(long maxSize)
: 截断Stream,使其元素不超过给定数量。skip(long n)
: 跳过Stream的前n个元素。
终端操作(Terminal Operations):这些操作会消费Stream,并产生一个最终结果或副作用,它们是触发中间操作执行的“开关”。常见的有:
forEach(Consumer)
: 遍历Stream中的每个元素并执行指定操作(无返回值,有副作用)。collect(Collector)
: 将Stream中的元素收集到新的集合、Map或其他数据结构中。reduce(BinaryOperator)
: 将Stream中的元素聚合成一个单一结果。count()
: 返回Stream中的元素数量。min(Comparator)
/max(Comparator)
: 找到Stream中的最小/最大元素。anyMatch(Predicate)
/allMatch(Predicate)
/noneMatch(Predicate)
: 检查Stream中的元素是否匹配给定条件。findFirst()
/findAny()
: 找到Stream中的第一个/任意一个元素。
为什么说是“新姿势”?
链式调用,可读性强:你可以将多个操作像链条一样连接起来,形成一个清晰的数据处理管道。比如,从一个学生列表中,找出所有及格的女生,然后按分数排序,最后打印出她们的名字。
import java.util.Arrays; import java.util.List; class Student { String name; String gender; int score; public Student(String name, String gender, int score) { this.name = name; this.gender = gender; this.score = score; } public String getName() { return name; } public String getGender() { return gender; } public int getScore() { return score; } } public class StreamExample { public static void main(String[] args) { List<Student> students = Arrays.asList( new Student("张三", "男", 75), new Student("李四", "女", 90), new Student("王五", "男", 60), new Student("赵六", "女", 88) ); students.stream() .filter(s -> s.getGender().equals("女")) // 筛选女生 .filter(s -> s.getScore() >= 60) // 筛选及格的 .sorted((s1, s2) -> Integer.compare(s2.getScore(), s1.getScore())) // 按分数降序 .map(Student::getName) // 提取名字 .forEach(System.out::println); // 遍历并打印 } }
这段代码的逻辑,一眼就能看明白它在做什么,比嵌套的for循环和if判断要清晰得多。
支持并行处理:Stream API可以轻松地转换为并行流(
parallelStream()
),利用多核CPU的优势进行并行计算,这对于处理大量数据时提升性能非常有帮助,而你几乎不需要关心并发编程的复杂性。List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); int sum = numbers.parallelStream() // 转换为并行流 .filter(n -> n % 2 == 0) // 筛选偶数 .mapToInt(Integer::intValue) // 转换为IntStream .sum(); // 求和 System.out.println("偶数和 (并行): " + sum);
函数式编程范式:它鼓励使用Lambda表达式和方法引用,让代码更紧凑、更专注于“做什么”而不是“怎么做”,这与现代编程语言的发展趋势是一致的。
当然,Stream API也不是万能的,它更适合于数据的转换和聚合,对于简单的遍历,for-each可能依然是最好的选择。但对于复杂的数据处理逻辑,Stream API无疑是提升代码质量和开发效率的利器。
终于介绍完啦!小伙伴们,这篇关于《Java集合遍历四方法全解析》的介绍应该让你收获多多了吧!欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识,快来关注吧!

- 上一篇
- AMD与英特尔性能对比全解析

- 下一篇
- JVM调优步骤与参数配置全解析
-
- 文章 · java教程 | 7分钟前 |
- Java高效读取文本转二维数组方法
- 394浏览 收藏
-
- 文章 · java教程 | 18分钟前 |
- Java读取DICOM影像数据教程
- 420浏览 收藏
-
- 文章 · java教程 | 27分钟前 | 并发 cas 原子类 ABA问题 AtomicInteger
- Java原子类原理与使用技巧解析
- 418浏览 收藏
-
- 文章 · java教程 | 28分钟前 |
- HashMap实现评分系统教程
- 120浏览 收藏
-
- 文章 · java教程 | 30分钟前 |
- JavaJNI教程:本地方法调用实战详解
- 138浏览 收藏
-
- 文章 · java教程 | 30分钟前 |
- JavaSocket异常处理与数据流选择方法
- 287浏览 收藏
-
- 文章 · java教程 | 46分钟前 |
- Java开发以太坊合约教程
- 373浏览 收藏
-
- 文章 · java教程 | 54分钟前 | java SpringBoot 平台 库存管理 变现
- Java库存系统模块解析与盈利策略
- 456浏览 收藏
-
- 文章 · java教程 | 58分钟前 |
- JavacompareTo重写陷阱及Comparator解决方法
- 138浏览 收藏
-
- 文章 · java教程 | 1小时前 |
- Java响应式编程案例详解
- 340浏览 收藏
-
- 文章 · java教程 | 1小时前 | 编码 try-with-resources Java文件读写 缓冲流 NIO.2
- Java文件读写操作入门指南
- 294浏览 收藏
-
- 前端进阶之JavaScript设计模式
- 设计模式是开发人员在软件开发过程中面临一般问题时的解决方案,代表了最佳的实践。本课程的主打内容包括JS常见设计模式以及具体应用场景,打造一站式知识长龙服务,适合有JS基础的同学学习。
- 542次学习
-
- GO语言核心编程课程
- 本课程采用真实案例,全面具体可落地,从理论到实践,一步一步将GO核心编程技术、编程思想、底层实现融会贯通,使学习者贴近时代脉搏,做IT互联网时代的弄潮儿。
- 511次学习
-
- 简单聊聊mysql8与网络通信
- 如有问题加微信:Le-studyg;在课程中,我们将首先介绍MySQL8的新特性,包括性能优化、安全增强、新数据类型等,帮助学生快速熟悉MySQL8的最新功能。接着,我们将深入解析MySQL的网络通信机制,包括协议、连接管理、数据传输等,让
- 498次学习
-
- JavaScript正则表达式基础与实战
- 在任何一门编程语言中,正则表达式,都是一项重要的知识,它提供了高效的字符串匹配与捕获机制,可以极大的简化程序设计。
- 487次学习
-
- 从零制作响应式网站—Grid布局
- 本系列教程将展示从零制作一个假想的网络科技公司官网,分为导航,轮播,关于我们,成功案例,服务流程,团队介绍,数据部分,公司动态,底部信息等内容区块。网站整体采用CSSGrid布局,支持响应式,有流畅过渡和展现动画。
- 484次学习
-
- 千音漫语
- 千音漫语,北京熠声科技倾力打造的智能声音创作助手,提供AI配音、音视频翻译、语音识别、声音克隆等强大功能,助力有声书制作、视频创作、教育培训等领域,官网:https://qianyin123.com
- 153次使用
-
- MiniWork
- MiniWork是一款智能高效的AI工具平台,专为提升工作与学习效率而设计。整合文本处理、图像生成、营销策划及运营管理等多元AI工具,提供精准智能解决方案,让复杂工作简单高效。
- 147次使用
-
- NoCode
- NoCode (nocode.cn)是领先的无代码开发平台,通过拖放、AI对话等简单操作,助您快速创建各类应用、网站与管理系统。无需编程知识,轻松实现个人生活、商业经营、企业管理多场景需求,大幅降低开发门槛,高效低成本。
- 160次使用
-
- 达医智影
- 达医智影,阿里巴巴达摩院医疗AI创新力作。全球率先利用平扫CT实现“一扫多筛”,仅一次CT扫描即可高效识别多种癌症、急症及慢病,为疾病早期发现提供智能、精准的AI影像早筛解决方案。
- 155次使用
-
- 智慧芽Eureka
- 智慧芽Eureka,专为技术创新打造的AI Agent平台。深度理解专利、研发、生物医药、材料、科创等复杂场景,通过专家级AI Agent精准执行任务,智能化工作流解放70%生产力,让您专注核心创新。
- 164次使用
-
- 提升Java功能开发效率的有力工具:微服务架构
- 2023-10-06 501浏览
-
- 掌握Java海康SDK二次开发的必备技巧
- 2023-10-01 501浏览
-
- 如何使用java实现桶排序算法
- 2023-10-03 501浏览
-
- Java开发实战经验:如何优化开发逻辑
- 2023-10-31 501浏览
-
- 如何使用Java中的Math.max()方法比较两个数的大小?
- 2023-11-18 501浏览