当前位置:首页 > 文章列表 > 文章 > java教程 > Java集合遍历四方法全解析

Java集合遍历四方法全解析

2025-08-12 17:53:43 0浏览 收藏

Java集合遍历是编程中常见的操作,本文深入解析四种主流方法,助你高效处理数据。**增强for循环**简洁易用,适合只读遍历;**迭代器**则能在遍历时安全删除元素,避免并发问题;**传统for循环**凭借索引优势,方便访问List集合;而**Java 8 Stream API**则以函数式编程风格,简化复杂的数据处理流程,支持过滤、映射、排序等操作,甚至能进行并行计算。选择哪种遍历方式,需根据实际需求,权衡代码可读性与性能,找到最合适的解决方案。

遍历Java集合元素主要有以下几种方法:1. 增强for循环适用于只读遍历,代码简洁;2. 迭代器适用于遍历中需安全删除元素的场景;3. 传统for循环适用于需索引访问的List集合;4. Java 8 Stream API适用于复杂数据处理,支持函数式编程和并行操作。选择应根据具体需求如是否需修改集合、是否依赖索引或追求代码可读性而定,最终方案完整且有效。

java如何使用循环语句遍历集合元素 java循环遍历集合的详细教程​

在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接口的实现类(如ArrayListVector),因为它们支持通过索引来访问元素。当你需要根据元素的索引进行操作,或者需要反向遍历时,传统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循环中修改集合,在多线程环境下,如果一个线程正在遍历集合,而另一个线程同时对集合进行了结构性修改(添加、删除元素),这个异常几乎是必然会发生的。这就像你正在看一本书,别人突然把书的几页撕掉了或者加了几页,你肯定会懵圈。

那么,怎么避免呢?

  1. 使用同步包装器(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。这有点反直觉,也容易出错。

  2. 使用并发集合类(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的线程安全版本,性能远超HashTableCollections.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());
      }
  3. 外部同步(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的核心思想是,你可以把集合看作是一个数据流,然后在这个流上进行一系列的操作,这些操作可以分为两类:

  1. 中间操作(Intermediate Operations):这些操作会返回一个新的Stream,它们是“懒惰的”,只有当终端操作被调用时才会真正执行。常见的有:

    • filter(Predicate): 过滤元素,只保留符合条件的。
    • map(Function): 将元素一对一地转换成另一种类型。
    • flatMap(Function): 将元素一对多地转换,并把结果扁平化成一个Stream。
    • sorted(): 对元素进行排序。
    • distinct(): 去除重复元素。
    • limit(long maxSize): 截断Stream,使其元素不超过给定数量。
    • skip(long n): 跳过Stream的前n个元素。
  2. 终端操作(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与英特尔性能对比全解析AMD与英特尔性能对比全解析
上一篇
AMD与英特尔性能对比全解析
JVM调优步骤与参数配置全解析
下一篇
JVM调优步骤与参数配置全解析
查看更多
最新文章
查看更多
课程推荐
  • 前端进阶之JavaScript设计模式
    前端进阶之JavaScript设计模式
    设计模式是开发人员在软件开发过程中面临一般问题时的解决方案,代表了最佳的实践。本课程的主打内容包括JS常见设计模式以及具体应用场景,打造一站式知识长龙服务,适合有JS基础的同学学习。
    542次学习
  • GO语言核心编程课程
    GO语言核心编程课程
    本课程采用真实案例,全面具体可落地,从理论到实践,一步一步将GO核心编程技术、编程思想、底层实现融会贯通,使学习者贴近时代脉搏,做IT互联网时代的弄潮儿。
    511次学习
  • 简单聊聊mysql8与网络通信
    简单聊聊mysql8与网络通信
    如有问题加微信:Le-studyg;在课程中,我们将首先介绍MySQL8的新特性,包括性能优化、安全增强、新数据类型等,帮助学生快速熟悉MySQL8的最新功能。接着,我们将深入解析MySQL的网络通信机制,包括协议、连接管理、数据传输等,让
    498次学习
  • JavaScript正则表达式基础与实战
    JavaScript正则表达式基础与实战
    在任何一门编程语言中,正则表达式,都是一项重要的知识,它提供了高效的字符串匹配与捕获机制,可以极大的简化程序设计。
    487次学习
  • 从零制作响应式网站—Grid布局
    从零制作响应式网站—Grid布局
    本系列教程将展示从零制作一个假想的网络科技公司官网,分为导航,轮播,关于我们,成功案例,服务流程,团队介绍,数据部分,公司动态,底部信息等内容区块。网站整体采用CSSGrid布局,支持响应式,有流畅过渡和展现动画。
    484次学习
查看更多
AI推荐
  • 千音漫语:智能声音创作助手,AI配音、音视频翻译一站搞定!
    千音漫语
    千音漫语,北京熠声科技倾力打造的智能声音创作助手,提供AI配音、音视频翻译、语音识别、声音克隆等强大功能,助力有声书制作、视频创作、教育培训等领域,官网:https://qianyin123.com
    153次使用
  • MiniWork:智能高效AI工具平台,一站式工作学习效率解决方案
    MiniWork
    MiniWork是一款智能高效的AI工具平台,专为提升工作与学习效率而设计。整合文本处理、图像生成、营销策划及运营管理等多元AI工具,提供精准智能解决方案,让复杂工作简单高效。
    147次使用
  • NoCode (nocode.cn):零代码构建应用、网站、管理系统,降低开发门槛
    NoCode
    NoCode (nocode.cn)是领先的无代码开发平台,通过拖放、AI对话等简单操作,助您快速创建各类应用、网站与管理系统。无需编程知识,轻松实现个人生活、商业经营、企业管理多场景需求,大幅降低开发门槛,高效低成本。
    160次使用
  • 达医智影:阿里巴巴达摩院医疗AI影像早筛平台,CT一扫多筛癌症急慢病
    达医智影
    达医智影,阿里巴巴达摩院医疗AI创新力作。全球率先利用平扫CT实现“一扫多筛”,仅一次CT扫描即可高效识别多种癌症、急症及慢病,为疾病早期发现提供智能、精准的AI影像早筛解决方案。
    155次使用
  • 智慧芽Eureka:更懂技术创新的AI Agent平台,助力研发效率飞跃
    智慧芽Eureka
    智慧芽Eureka,专为技术创新打造的AI Agent平台。深度理解专利、研发、生物医药、材料、科创等复杂场景,通过专家级AI Agent精准执行任务,智能化工作流解放70%生产力,让您专注核心创新。
    164次使用
微信登录更方便
  • 密码登录
  • 注册账号
登录即同意 用户协议隐私政策
返回登录
  • 重置密码