Java遍历Set的四种方法

在Java中遍历Set集合是常见的操作，本文深入探讨了三种核心方法：迭代器（Iterator）、增强型for循环（Enhanced For Loop）以及Java 8引入的Stream API和forEach方法。针对每种方法，文章详细讲解了其适用场景、优缺点以及使用示例，并着重强调了在遍历过程中可能遇到的`ConcurrentModificationException`等问题，并提供了相应的解决方案，例如使用迭代器的`remove()`方法、创建新集合、使用`removeIf()`方法以及`CopyOnWriteArraySet`等。通过本文，读者能够清晰地了解如何在Java中高效、安全地遍历和修改Set集合，并根据实际需求选择最佳实践，写出更健壮的代码。

遍历Set集合的核心方法有三种：使用迭代器可在遍历时安全删除元素；增强for循环语法简洁，适合仅读取场景；Java 8的Stream API和forEach适用于函数式编程与复杂数据处理。选择依据包括Java版本、是否需修改集合、操作复杂度及性能需求。遍历时常见问题有ConcurrentModificationException、HashSet无序性、性能开销和线程安全。安全修改方式包括迭代器remove()、创建新集合、使用removeIf()及CopyOnWriteArraySet。

在Java中遍历Set集合，核心思路无非是“逐个访问”其内部元素。最直接且常用的方式有三种：使用迭代器（Iterator）、增强型for循环（Enhanced For Loop），以及在Java 8及更高版本中引入的Stream API和forEach方法。每种方法都有其适用场景和一些小“脾气”，理解它们能帮助我们写出更健壮、更高效的代码。

解决方案

遍历Set集合的方法，其实并没有什么神秘之处，关键在于理解每种方式的特点和适用性。

1. 使用迭代器（Iterator）

这是Java集合框架中最“古老”也是最基础的遍历方式。迭代器提供了一种统一的访问集合元素的方式，而且它有一个独有的能力：在遍历过程中安全地移除元素。

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetIterationDemo {
    public static void main(String[] args) {
        Set<String> names = new HashSet<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");

        System.out.println("--- 使用迭代器遍历 ---");
        Iterator<String> iterator = names.iterator();
        while (iterator.hasNext()) {
            String name = iterator.next();
            System.out.println("Hello, " + name);
            // 假设我们要移除名字是 "Bob" 的元素
            if ("Bob".equals(name)) {
                iterator.remove(); // 安全移除当前元素
            }
        }
        System.out.println("移除 'Bob' 后集合: " + names);
    }
}

我个人觉得，当你需要在遍历时对集合进行结构性修改（比如删除元素）时，迭代器几乎是唯一的原生安全选择。

2. 使用增强型for循环（Enhanced For Loop / foreach）

这是我们日常编码中最常用、最简洁的遍历方式。它的语法非常优雅，省去了手动管理迭代器对象的繁琐。

import java.util.HashSet;
import java.util.Set;

public class SetIterationDemo {
    public static void main(String[] args) {
        Set<String> fruits = new HashSet<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        System.out.println("\n--- 使用增强型for循环遍历 ---");
        for (String fruit : fruits) {
            System.out.println("I like " + fruit);
            // 注意：这里不能直接修改集合（如fruits.remove(fruit)），否则会抛出ConcurrentModificationException
        }
    }
}

增强型for循环本质上是迭代器的语法糖。它在编译时会被转换为使用迭代器的形式，所以它也继承了迭代器的一些“规矩”，比如在遍历过程中不能直接通过集合对象修改集合结构。

3. 使用Java 8 Stream API 和 forEach 方法

Java 8引入的Stream API为集合操作带来了函数式编程的范式，让集合处理变得更加流畅和富有表现力。forEach方法是Stream API中的一个终端操作，也可以直接在Iterable接口（Set实现了Collection，Collection实现了Iterable）上调用。

import java.util.HashSet;
import java.util.Set;

public class SetIterationDemo {
    public static void main(String[] args) {
        Set<Integer> numbers = new HashSet<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        System.out.println("\n--- 使用Stream API遍历 ---");
        numbers.stream()
               .filter(n -> n > 15) // 举个例子，过滤一下
               .forEach(n -> System.out.println("Number: " + n));

        System.out.println("\n--- 使用Set的forEach方法遍历 ---");
        numbers.forEach(n -> System.out.println("Direct Number: " + n));
    }
}

Stream API在处理大量数据、进行链式操作（如过滤、映射、排序等）时优势明显，代码可读性也非常好。直接在Set上调用的forEach方法则更简洁，适合简单的遍历操作。

什么时候应该选择哪种遍历方式？

这个问题，我经常在代码评审时和同事们讨论。选择哪种遍历方式，真的不是拍脑袋决定的，它取决于你的具体需求和Java版本。

首先，如果你还在用Java 7或更早的版本，那Stream API和forEach就不用考虑了。你的选择基本就是迭代器和增强for循环。这时候，如果仅仅是读取元素，增强for循环无疑是首选，因为它代码最简洁，可读性也高。但如果你需要在遍历过程中移除元素，那么迭代器就是你的不二之选，它的remove()方法是专门为此设计的。

其次，如果你已经拥抱了Java 8及更高版本，那么选择就多了起来。

• 仅仅是读取元素并进行简单处理：增强for循环依旧是一个非常好的选择，它直观、高效。或者，如果你喜欢函数式编程的风格，Set.forEach(element -> { ... }) 也非常简洁。
• 需要在遍历过程中移除元素：迭代器的remove()方法依然是最佳实践。但如果你只是想根据某个条件批量移除元素，Java 8的Collection.removeIf(Predicate filter)方法会更优雅、更高效，因为它在内部处理了并发修改的问题，避免了手动迭代的麻烦。
• 需要进行复杂的链式操作：比如先过滤、再转换、再收集，或者需要并行处理以提升性能。这种情况下，Stream API的优势就体现出来了。它的filter(), map(), reduce(), collect()等方法组合起来，能以非常声明式的方式完成复杂的数据处理逻辑。我个人在处理数据转换时，更倾向于Stream，它让代码看起来像在描述“做什么”，而不是“怎么做”。
• 性能考量：对于小型集合，各种遍历方式的性能差异微乎其微。但对于大型集合，尤其是需要并行处理时，Stream API的并行流（parallelStream()）可能会带来显著的性能提升，但这也不是万能药，并行流的开销也需要考虑，不恰当的使用反而可能降低性能。

总的来说，没有“最好”的遍历方式，只有“最适合”你当前场景的方式。

遍历Set时有哪些常见的“坑”或注意事项？

说起来简单，但实际操作中总会遇到些小麻烦，或者一些容易被忽视的细节。

第一个也是最常见的“坑”就是 ConcurrentModificationException。当你使用迭代器或者增强for循环遍历一个Set时，如果你在循环体内部通过Set对象本身（而不是迭代器的remove()方法）去添加或删除元素，那么恭喜你，你很可能会看到这个异常。这是因为迭代器在创建时会记录集合的“修改次数”，如果这个次数在遍历过程中被集合自身的修改操作改变了，迭代器就会认为集合被“并发修改”了，从而抛出异常。这是一个快速失败（fail-fast）机制，旨在提醒你代码可能存在问题。唯一的例外是迭代器自身的remove()方法，它是被允许的。

第二个需要注意的点是 Set的无序性。尤其是HashSet，它不保证元素的存储顺序，也不保证遍历时的顺序。这意味着你每次运行程序，或者即使不重启程序，多次遍历同一个HashSet，元素的输出顺序都可能不一样。如果你对元素的顺序有要求，比如希望按照插入顺序遍历，你应该考虑使用LinkedHashSet；如果希望元素按照自然顺序（或自定义顺序）排序后遍历，那么TreeSet是更好的选择。我在项目里遇到过很多次，新人不理解HashSet的无序性，结果写出来的代码在测试环境没问题，一到生产环境就因为顺序问题出错了。

第三个是 性能的权衡。虽然Java 8的Stream API非常强大，但它并不是银弹。对于非常小的集合，或者仅仅是简单的遍历打印，Stream API的开销（创建Stream对象、Lambda表达式的调用等）可能比直接的增强for循环还要大。所以，不要盲目追求“新特性”，要根据实际情况来选择。我倾向于在数据量较大、或者逻辑比较复杂需要链式操作时才考虑Stream。

第四个是 线程安全问题。如果你的Set是在多线程环境下共享的，并且可能会被多个线程同时遍历和修改，那么普通的HashSet、LinkedHashSet、TreeSet都不是线程安全的。这会导致不可预测的行为，甚至数据丢失。这时候，你需要考虑使用线程安全的集合，比如Collections.synchronizedSet(new HashSet<>())，或者更高级的并发集合，如CopyOnWriteArraySet。CopyOnWriteArraySet在读操作非常多而写操作很少的场景下表现出色，因为它在修改时会复制底层数组，保证了读操作的无锁。

如何在遍历Set时安全地修改元素？

在遍历Set时修改元素，确实是个需要小心处理的问题，前面也提到了ConcurrentModificationException。但我们总不能因为怕出错就不修改了，对吧？这里有几种安全地修改Set元素的方法。

1. 使用迭代器的 remove() 方法

这是最直接、最推荐的方式，当你的修改意图是移除当前正在遍历的元素时。

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SafeModificationDemo {
    public static void main(String[] args) {
        Set<String> users = new HashSet<>();
        users.add("Alice");
        users.add("Bob");
        users.add("Charlie");
        users.add("David");

        System.out.println("原始用户列表: " + users);

        Iterator<String> userIterator = users.iterator();
        while (userIterator.hasNext()) {
            String user = userIterator.next();
            if ("Bob".equals(user) || "David".equals(user)) {
                System.out.println("移除用户: " + user);
                userIterator.remove(); // 安全移除
            }
        }
        System.out.println("移除后用户列表: " + users);
    }
}

注意，iterator.remove()只能移除iterator.next()返回的最后一个元素。如果你想在遍历时添加元素，或者修改非当前元素，这种方式就不适用了。

2. 创建一个新集合

这是一种非常通用且安全的方法，尤其适用于你需要添加或修改大量元素，或者移除的元素不是当前迭代的元素时。你遍历旧集合，然后将需要保留或修改的元素添加到新集合中。遍历完成后，用新集合替换旧集合。

import java.util.HashSet;
import java.util.Set;

public class SafeModificationDemo {
    public static void main(String[] args) {
        Set<Integer> scores = new HashSet<>();
        scores.add(85);
        scores.add(92);
        scores.add(78);
        scores.add(60);
        scores.add(95);

        System.out.println("原始分数: " + scores);

        Set<Integer> updatedScores = new HashSet<>();
        for (Integer score : scores) {
            if (score < 70) {
                // 假设我们要把所有低于70分的分数都改为70
                updatedScores.add(70);
            } else {
                updatedScores.add(score);
            }
        }
        // 如果要移除所有低于70分的，可以直接过滤掉
        // for (Integer score : scores) {
        //     if (score >= 70) {
        //         updatedScores.add(score);
        //     }
        // }

        scores = updatedScores; // 用新集合替换旧集合
        System.out.println("修改后分数: " + scores);
    }
}

这种方法的优点是简单、安全，但缺点是会创建新的集合对象，可能带来额外的内存开销，尤其是在集合非常大的时候。

3. 使用Java 8的 removeIf() 方法

如果你只是想根据某个条件批量移除元素，Java 8为Collection接口（因此也包括Set）提供了一个非常方便且高效的方法：removeIf(Predicate filter)。这个方法在内部安全地处理了迭代和移除的逻辑。

import java.util.HashSet;
import java.util.Set;

public class SafeModificationDemo {
    public static void main(String[] args) {
        Set<String> tasks = new HashSet<>();
        tasks.add("Clean room");
        tasks.add("Buy groceries");
        tasks.add("Write report");
        tasks.add("Pay bills");

        System.out.println("原始任务: " + tasks);

        // 移除所有包含 "report" 的任务
        tasks.removeIf(task -> task.contains("report"));
        System.out.println("移除 'report' 任务后: " + tasks);

        // 移除所有长度小于8的任务
        tasks.removeIf(task -> task.length() < 8);
        System.out.println("移除短任务后: " + tasks);
    }
}

removeIf()方法是我个人非常喜欢的一个特性，它让代码变得非常简洁和富有表现力，同时避免了手动迭代可能带来的ConcurrentModificationException。

4. 使用线程安全的集合

如果你是在多线程环境下操作Set，并且需要保证并发安全，那么可以考虑使用CopyOnWriteArraySet。它在每次修改操作（add, remove）时都会创建一个新的底层数组，从而保证了迭代器在遍历时看到的集合状态是修改前的快照，不会出现ConcurrentModificationException。

import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;

public class ConcurrentSetDemo {
    public static void main(String[] args) {
        Set<String> sharedLogs = new CopyOnWriteArraySet<>();
        sharedLogs.add("Log A");
        sharedLogs.add("Log B");

        // 线程1：遍历并打印日志
        new Thread(() -> {
            for (String log : sharedLogs) {
                try {
                    Thread.sleep(100); // 模拟耗时操作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println(Thread.currentThread().getName() + " reading: " + log);
            }
        }, "ReaderThread").start();

        // 线程2：在遍历过程中添加新的日志
        new Thread(() -> {
            try {
                Thread.sleep(50); // 让读线程先启动
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            sharedLogs.add("Log C - Added by Writer");
            System.out.println(Thread.currentThread().getName() + " added Log C. Current logs: " + sharedLogs);
        }, "WriterThread").start();

        // 主线程等待一段时间，观察结果
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Final logs: " + sharedLogs);
    }
}

CopyOnWriteArraySet的缺点是，每次修改都会复制整个数组，这对于写操作频繁的场景来说性能开销会非常大。所以，它更适合读多写少的场景。

选择哪种安全修改方式，同样需要根据具体场景来定。简单移除当前元素就用迭代器remove()；批量条件移除用removeIf()；复杂修改或需要创建新集合时，就手动构建新集合；多线程且读多写少时，考虑CopyOnWriteArraySet。理解这些工具的特点，能让你在Java的集合操作中游刃有余。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~