Java 中遍历列表（Iterate List in Java）

简介

在 Java 编程中，列表（List）是一种常用的数据结构，用于存储有序且可重复的元素集合。遍历列表，即按顺序访问列表中的每个元素，是一个常见的操作。掌握如何有效地遍历列表对于编写高效、简洁的 Java 代码至关重要。本文将详细介绍在 Java 中遍历列表的基础概念、多种使用方法、常见实践以及最佳实践。

目录

1. 基础概念
2. 使用方法
   • 传统 for 循环
   • 增强 for 循环（foreach）
   • 迭代器（Iterator）
   • 列表迭代器（ListIterator）
   • Java 8 流（Stream API）
3. 常见实践
   • 遍历并修改列表元素
   • 遍历并删除列表元素
4. 最佳实践
5. 小结
6. 参考资料

基础概念

列表（List）是 Java 集合框架（Collection Framework）中的一个接口，它继承自 Collection 接口。常见的实现类有 ArrayList、LinkedList 等。遍历列表就是按照一定的顺序逐个访问列表中的元素，以便对每个元素进行处理，比如打印、计算、修改等操作。

使用方法

传统 for 循环

传统的 for 循环是最基本的遍历方式，通过索引来访问列表中的元素。

import java.util.ArrayList;
import java.util.List;

public class TraditionalForLoop {
    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 element = list.get(i);
            System.out.println(element);
        }
    }
}

增强 for 循环（foreach）

增强 for 循环是 Java 5 引入的语法糖，它简化了遍历集合和数组的操作，无需手动管理索引。

import java.util.ArrayList;
import java.util.List;

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

        for (String element : list) {
            System.out.println(element);
        }
    }
}

迭代器（Iterator）

迭代器是 Java 集合框架中用于遍历集合的接口。它提供了一种统一的方式来遍历不同类型的集合。

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 element = iterator.next();
            System.out.println(element);
        }
    }
}

列表迭代器（ListIterator）

列表迭代器是 List 接口特有的迭代器，它允许双向遍历列表，并且可以在遍历过程中添加、修改和删除元素。

import java.util.ArrayList;
import java.util.ListIterator;

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

        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            String element = listIterator.next();
            System.out.println(element);
        }
        // 反向遍历
        while (listIterator.hasPrevious()) {
            String element = listIterator.previous();
            System.out.println(element);
        }
    }
}

Java 8 流（Stream API）

Java 8 引入的流 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.stream().forEach(System.out::println);

        // 过滤并收集元素
        List<String> filteredList = list.stream()
              .filter(s -> s.length() > 5)
              .collect(Collectors.toList());
        System.out.println(filteredList);
    }
}

常见实践

遍历并修改列表元素

使用传统 for 循环或列表迭代器可以方便地修改列表元素。

import java.util.ArrayList;
import java.util.ListIterator;

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

        // 使用传统 for 循环
        for (int i = 0; i < list.size(); i++) {
            list.set(i, list.get(i).toUpperCase());
        }
        System.out.println(list);

        // 使用列表迭代器
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            String element = listIterator.next();
            listIterator.set(element.toLowerCase());
        }
        System.out.println(list);
    }
}

遍历并删除列表元素

使用迭代器或流 API 的 filter 方法可以安全地删除列表元素。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

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

        // 使用迭代器
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            if (element.length() < 6) {
                iterator.remove();
            }
        }
        System.out.println(list);

        // 使用流 API
        list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        list = list.stream()
              .filter(s -> s.length() >= 6)
              .collect(Collectors.toList());
        System.out.println(list);
    }
}

最佳实践

• 性能考虑：对于随机访问频繁的列表（如 ArrayList），传统 for 循环可能具有更好的性能，因为它直接通过索引访问元素。对于顺序访问频繁的列表（如 LinkedList），迭代器或增强 for 循环可能更合适。
• 代码简洁性：如果只需要简单地遍历列表并对每个元素进行操作，增强 for 循环或流 API 可以使代码更简洁。
• 修改列表：在遍历过程中需要修改列表时，使用列表迭代器或流 API 的 filter 方法可以避免 ConcurrentModificationException 异常。

小结

本文详细介绍了在 Java 中遍历列表的多种方法，包括传统 for 循环、增强 for 循环、迭代器、列表迭代器以及 Java 8 流 API。同时，通过代码示例展示了常见实践，如遍历并修改、删除列表元素。在实际应用中，应根据具体需求选择合适的遍历方式，以实现代码的高效性和简洁性。

参考资料

• Oracle Java Documentation
• Effective Java, Third Edition