Java集合遍历全指南(迭代器&增强for及列表迭代器)

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

public class IteratorDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        // 1. 获取迭代器对象
        Iterator<String> it = list.iterator();

        // 2. 遍历：先判断，再取值
        while (it.hasNext()) {
            // 3. 获取当前元素，指针自动后移
            String str = it.next();
            System.out.println(str);

            // 可选：删除上一次next()返回的元素（此处演示删除"bbb"）
            if ("bbb".equals(str)) {
                it.remove(); // 仅迭代器remove可用，不会抛并发修改异常
            }
        }

        // 遍历完毕，指针不复位，重新遍历需重新获取迭代器
        Iterator<String> it2 = list.iterator();
        while (it2.hasNext()) {
            System.out.println(it2.next()); // 输出：aaa、ccc
        }
    }
}

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

public class ListIteratorDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        // 1. 获取List集合专属的列表迭代器
        ListIterator<String> it2 = list.listIterator();

        // 2. 向后遍历，遍历中添加元素
        while (it2.hasNext()) {
            String str2 = it2.next();
            System.out.println(str2);
            // 当遍历到"bbb"时，在其后面添加"qqq"
            if ("bbb".equals(str2)) {
                it2.add("qqq"); // 遍历中添加，无异常
            }
        }
        System.out.println("添加元素后：" + list); // 输出：[aaa, bbb, qqq, ccc]

        // 3. 向前遍历（演示双向遍历）
        System.out.println("向前遍历：");
        while (it2.hasPrevious()) {
            String str3 = it2.previous();
            System.out.println(str3); // 输出：ccc、qqq、bbb、aaa
        }
    }
}

for(元素的数据类型 变量名 : 数组或者单列集合) {
    // 循环体：变量名 依次表示集合/数组中的每一个元素
}

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

public class ForEachDemo {
    public static void main(String[] args) {
        // 1. 增强 for 遍历 List 集合
        List<String> list = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");

        for (String s : list) {
            System.out.println(s); // s 依次表示集合中的每一个元素
        }

        // 2. 增强 for 遍历数组
        Integer[] arr = {1, 2, 3, 4, 5};
        for (Integer num : arr) {
            System.out.println(num); // num 依次表示数组中的每一个元素
        }

        // 重要细节：修改第三方变量s，不会改变集合本身的值
        for (String s : list) {
            s = "zhaoliu"; // 仅修改变量s的值，集合中的元素不变
        }
        System.out.println("修改后集合：" + list); // 输出：[zhangsan, lisi, wangwu]
    }
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class AllTraversalDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        // 1. 迭代器遍历（可删除）
        System.out.println("=== 迭代器遍历 ===");
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String str = it.next();
            System.out.println(str);
        }

        // 2. 列表迭代器遍历（可增删、双向）
        System.out.println("=== 列表迭代器遍历 ===");
        ListIterator<String> it2 = list.listIterator();
        while (it2.hasNext()) {
            String str2 = it2.next();
            if ("bbb".equals(str2)) {
                it2.add("qqq"); // 遍历中添加
            }
            System.out.println(str2);
        }

        // 3. 增强 for 遍历（仅遍历）
        System.out.println("=== 增强 for 遍历 ===");
        for (String s : list) {
            System.out.println(s);
        }

        // 4. 普通 for 循环遍历（操作索引）
        System.out.println("=== 普通 for 遍历 ===");
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
            // 可操作索引：修改指定位置元素
            if (i == 0) {
                list.set(i, "aaa111");
            }
        }

        // 5. Lambda 表达式遍历（极简）
        System.out.println("=== Lambda 遍历 ===");
        list.forEach(s -> System.out.println(s));
    }
}

// ArrayList 中获取迭代器的方法
public Iterator<E> iterator() {
    return new Itr(); // 每次调用iterator()，都会创建一个新的Itr对象（内部类）
}

// 迭代器的底层实现：ArrayList的内部类Itr，实现了Iterator接口
private class Itr implements Iterator<E> {
    int cursor;      // 迭代器指针（光标），默认指向集合0索引
    int lastRet = -1; // 记录上一次调用next()返回的元素索引，初始值-1（表示未操作）
    int expectedModCount = modCount; // 记录集合的修改次数（创建迭代器时的初始次数）

    // hasNext()原理：判断指针是否到达集合末尾（cursor等于集合大小，说明无元素）
    public boolean hasNext() {
        return cursor != size;
    }

    // next()原理：获取当前指针元素，指针后移，并校验集合是否被修改
    public E next() {
        checkForComodification(); // 核心校验：判断集合是否被非法修改
        int i = cursor; // 记录当前指针位置
        if (i >= size)
            throw new NoSuchElementException(); // 指针越界，抛异常
        Object[] elementData = ArrayList.this.elementData; // 获取ArrayList底层数组
        if (i >= elementData.length)
            throw new ConcurrentModificationException(); // 并发修改异常
        cursor = i + 1; // 指针后移一位
        return (E) elementData[lastRet = i]; // 返回当前元素，并更新lastRet
    }

    // 校验集合是否被修改：expectedModCount（迭代器记录的次数） != modCount（集合实际次数）
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}