【Java集合夜话】第4篇：遍历艺术，从基础循环到函数式编程的进阶之路

在上一章中，我们深入探索了Map家族的实现原理，领略了不同Map类型的设计智慧。🌹

今天，让我们一起探讨集合遍历的艺术。从最基础的for循环到现代化的Stream API，每种遍历方式都有其独特的魅力和应用场景。通过这篇文章，你不仅能掌握各种遍历技巧，更能理解Java编程范式的演进历程。🌹

如有描述不准确之处，欢迎大家指出交流。🌹

一、从最简单的for循环说起

在Java集合遍历的世界里，for循环可以说是最古老也最基础的方式。它就像一把瑞士军刀，简单可靠，虽然不够优雅，但却能应对各种场景。让我们从这里开始我们的遍历艺术之旅。

1.1 基础for循环：古老而可靠的老兵

最基本的for循环，相信每个Java程序员都不陌生：

List<String> list = Arrays.asList("Java", "Python", "Go");
for (int i = 0; i < list.size(); i++) {
   
    System.out.println(list.get(i));
}

这种方式看似简单，但它其实暗藏玄机。让我们深入分析一下它的优缺点：

优点

• 最直观、最基础的遍历方式：代码逻辑清晰，易于理解和调试
• 可以精确控制索引：需要索引信息时的不二选择
• 可以同时操作多个集合：当需要同时遍历多个集合时特别有用
• 支持复杂的遍历逻辑：比如按特定步长遍历、同时访问前后元素等

缺点

• 代码较为冗长：相比其他现代遍历方式，需要更多的样板代码
• 需要手动维护索引：容易出现越界等问题
• 性能隐患：如果在循环中重复调用size()方法，可能影响性能

最佳实践

在使用基础for循环时，有一些小技巧可以让代码更优：

// 避免重复调用size()方法
for (int i = 0, size = list.size(); i < size; i++) {
   
    // 操作元素
}

为什么要这样做？因为在某些情况下，size()方法可能需要遍历整个集合（比如LinkedList），提前获取size可以避免重复计算。

使用场景

基础for循环特别适合以下场景：

1. 需要使用索引：比如需要知道元素在集合中的位置
2. 需要修改索引：比如跳过某些元素
3. 需要反向遍历：从后向前遍历时特别有用
4. 同时遍历多个集合：当需要同步处理多个集合的元素时

// 反向遍历的例子
for (int i = list.size() - 1; i >= 0; i--) {
   
    System.out.println(list.get(i));
}

// 同时遍历多个集合
for (int i = 0; i < Math.min(list1.size(), list2.size()); i++) {
   
    process(list1.get(i), list2.get(i));
}

性能考虑

对于ArrayList这样的随机访问集合，基础for循环的性能是很好的，因为get(i)操作的时间复杂度是O(1)。但对于LinkedList这样的顺序访问集合，每次get(i)都需要从头遍历到第i个元素，时间复杂度是O(n)，这时应该避免使用基础for循环。

// 对LinkedList，这样的遍历方式性能很差
LinkedList<String> linkedList = new LinkedList<>();
for (int i = 0; i < linkedList.size(); i++) {
   
    linkedList.get(i); // 每次get都要从头遍历！
}

注意事项

1. 越界检查：确保索引不会超出集合范围
2. 性能优化：提前保存size值
3. 集合类型：注意区分随机访问集合和顺序访问集合
4. 并发修改：在遍历时修改集合可能导致问题

1.2 迭代器：面向对象的遍历方式

迭代器模式是Java集合框架中最重要的设计模式之一。它提供了一种统一的遍历集合的方式，将遍历的行为从集合中抽离出来，形成了一个独立的对象。这种设计不仅优雅，而且为集合的安全遍历提供了保障。

基本用法

最基本的迭代器使用方式如下：

List<String> list = Arrays.asList("Java", "Python", "Go");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
   
    String item = iterator.next();
    System.out.println(item);
}

深入理解迭代器

迭代器的工作原理比表面看起来要复杂得多。它维护了一个游标，指向当前遍历的位置，并提供了三个核心方法：

• hasNext()：检查是否还有下一个元素
• next()：获取下一个元素
• remove()：删除当前元素（可选操作）

迭代器的优势

1. 统一的遍历接口

   • 无论是ArrayList、LinkedList还是HashSet，都可以用相同的方式遍历
   • 屏蔽了底层数据结构的差异

2. 支持安全删除

   • 提供了线程安全的删除方法
   • 避免了并发修改异常

3. 无需关心索引

   • 特别适合链表等顺序访问的数据结构
   • 避免了索引越界的问题

常见陷阱与解决方案

1. 并发修改问题

// 错误示例：直接使用集合的删除方法
for (String item : list) {
     // 底层使用的是迭代器
    if ("Java".equals(item)) {
   
        list.remove(item); // 会抛出ConcurrentModificationException
    }
}

// 正确示例：使用迭代器的remove方法
Iterator<String> it = list.iterator();
while (it.hasNext()) {
   
    String item = it.next();
    if ("Java".equals(item)) {
   
        it.remove(); // 安全的删除方式
    }
}

2. 迭代器状态管理

// 错误示例：重复调用next()
Iterator<String> it = list.iterator();
if (it.hasNext()) {
   
    String first = it.next();
    String second = it.next(); // 可能抛出NoSuchElementException
}

// 正确示例：每次调用next()前都检查hasNext()
Iterator<String> it = list.iterator();
while (it.hasNext()) {
   
    String item = it.next();
    // 处理元素
}

实际应用场景

1. 安全删除元素

public void removeExpiredItems(List<Item> items) {
   
    Iterator<Item> it = items.iterator();
    while (it.hasNext()) {
   
        Item item = it.next();
        if (item.isExpired()) {
   
            it.remove();
        }
    }
}

2. 自定义过滤器

public class FilterIterator<T> implements Iterator<T> {
   
    private final Iterator<T> iterator;
    private final Predicate<T> predicate;
    private T nextElement;
    private boolean hasNext;

    public FilterIterator(Iterator<T> iterator, Predicate<T> predicate) {
   
        this.iterator = iterator;
        this.predicate = predicate;
        advance();
    }

    private void advance() {
   
        while (iterator.hasNext()) {
   
            nextElement = iterator.next();
            if (predicate.test(nextElement)) {
   
                hasNext = true;
                return;
            }
        }
        hasNext = false;
    }

    @Override
    public boolean hasNext() {
   
        return hasNext;
    }

    @Override
    public T next() {
   
        if (!hasNext) {
   
            throw new NoSuchElementException();
        }
        T result = nextElement;
        advance();
        return result;
    }
}

// 使用示例
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Iterator<Integer> evenNumbers = new FilterIterator<>(
    numbers.iterator(),
    num -> num % 2 == 0
);

性能考虑

迭代器的性能主要取决于底层集合的实现：

• 对于ArrayList，迭代器的性能接近于普通for循环
• 对于LinkedList，迭代器的性能远优于普通for循环
• 迭代器本身会产生额外的对象创建开销，但这个开销通常可以忽略不计

最佳实践建议

1. 优先使用增强for循环（它在底层使用迭代器）
2. 需要删除元素时，使用迭代器的remove方法
3. 避免在迭代过程中修改集合（除非通过迭代器的方法）
4. 注意保持迭代器的单向遍历，不要在遍历过程中重复使用迭代器

二、增强for循环：优雅的语法糖

增强for循环（foreach）是Java 5引入的一个重要特性，它极大地简化了集合的遍历操作。虽然被称为"语法糖"，但它的引入不仅提高了代码的可读性，更反映了Java在易用性方面的重要进步。

2.1 基本用法与原理

基本语法

List<String> list = Arrays.asList("Java", "Python", "Go");
for (String item : list) {
   
    System.out.println(item);
}

编译原理

很多开发者可能不知道，增强for循环在编译后会被转换为迭代器的形式：

// 增强for循环的实际编译结果
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()) {
   
    String item = iterator.next();
    System.out.println(item);
}

这个转换过程解释了为什么增强for循环也会遇到ConcurrentModificationException的问题。

2.2 适用范围

增强for循环不仅可以用于集合，还可以用于：

1. 所有实现了Iterable接口的类
2. 数组

// 用于数组
int[] numbers = {
   1, 2, 3, 4, 5};
for (int number : numbers) {
   
    System.out.println(number);
}

// 用于自定义Iterable类
public class Range implements Iterable<Integer> {
   
    private final int start;
    private final int end;
    
    public Range(int start, int end) {
   
        this.start = start;
        this.end = end;
    }
    
    @Override
    public Iterator<Integer> iterator() {
   
        return new Iterator<Integer>() {
   
            private int current = start;
            
            @Override
            public boolean hasNext() {
   
                return current < end;
            }
            
            @Override
            public Integer next() {
   
                return current++;
            }
        };
    }
}

// 使用示例
Range range = new Range(1, 5);
for (int i : range) {
   
    System.out.println(i);
}

2.3 性能分析

不同集合类型的性能表现

// 1. ArrayList的情况
ArrayList<String> arrayList = new ArrayList<>();
// 性能接近普通for循环，因为底层使用数组
for (String item : arrayList) {
    /* 操作 */ }

// 2. LinkedList的情况
LinkedList<String> linkedList = new LinkedList<>();
// 性能优于普通for循环，因为使用迭代器避免了重复遍历
for (String item : linkedList) {
    /* 操作 */ }

// 3. HashSet的情况
HashSet<String> hashSet = new HashSet<>();
// 是唯一可行的遍历方式，因为没有索引
for (String item : hashSet) {
    /* 操作 */ }

性能优化建议

1. 避免装箱拆箱

// 不推荐：会导致频繁的装箱操作
List<Integer> numbers = Arrays.asList(1, 2, 3);
for (int num : numbers) {
    /* 操作 */ }

// 推荐：使用基本类型数组
int[] numbers = {
   1, 2, 3};
for (int num : numbers) {
    /* 操作 */ }

2. 合理使用集合类型

// 对于需要随机访问的场景
List<String> list = new ArrayList<>();  // 优先使用ArrayList

// 对于频繁增删的场景
List<String> list = new LinkedList<>();  // 使用LinkedList

2.4 常见陷阱与注意事项

1. 不能修改集合大小

// 错误示例：会抛出ConcurrentModificationException
for (String item : list) {
   
    if (condition) {
   
        list.remove(item);  // 不要这样做！
    }
}

// 正确示例：使用迭代器
Iterator<String> it = list.iterator();
while (it.hasNext()) {
   
    String item = it.next();
    if (condition) {
   
        it.remove();  // 使用迭代器的remove方法
    }
}

2. 无法获取索引

// 如果需要索引，可以这样做
List<String> list = Arrays.asList("A", "B", "C");
int index = 0;
for (String item : list) {
   
    System.out.printf("Index: %d, Value: %s%n", index++, item);
}

// 或者使用IntStream
IntStream