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. 獲取當(dāng)前元素，指針自動后移
            String str = it.next();
            System.out.println(str);

            // 可選：刪除上一次next()返回的元素（此處演示刪除"bbb"）
            if ("bbb".equals(str)) {
                it.remove(); // 僅迭代器remove可用，不會拋并發(fā)修改異常
            }
        }

        // 遍歷完畢，指針不復(fù)位，重新遍歷需重新獲取迭代器
        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);
            // 當(dāng)遍歷到"bbb"時(shí)，在其后面添加"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(元素的數(shù)據(jù)類型 變量名 : 數(shù)組或者單列集合) {
    // 循環(huán)體：變量名 依次表示集合/數(shù)組中的每一個元素
}

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

public class ForEachDemo {
    public static void main(String[] args) {
        // 1. 增強(qiáng) 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. 增強(qiáng) for 遍歷數(shù)組
        Integer[] arr = {1, 2, 3, 4, 5};
        for (Integer num : arr) {
            System.out.println(num); // num 依次表示數(shù)組中的每一個元素
        }

        // 重要細(xì)節(jié)：修改第三方變量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. 增強(qiáng) for 遍歷（僅遍歷）
        System.out.println("=== 增強(qiáng) for 遍歷 ===");
        for (String s : list) {
            System.out.println(s);
        }

        // 4. 普通 for 循環(huán)遍歷（操作索引）
        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 表達(dá)式遍歷（極簡）
        System.out.println("=== Lambda 遍歷 ===");
        list.forEach(s -> System.out.println(s));
    }
}

// ArrayList 中獲取迭代器的方法
public Iterator<E> iterator() {
    return new Itr(); // 每次調(diào)用iterator()，都會創(chuàng)建一個新的Itr對象（內(nèi)部類）
}

// 迭代器的底層實(shí)現(xiàn)：ArrayList的內(nèi)部類Itr，實(shí)現(xiàn)了Iterator接口
private class Itr implements Iterator<E> {
    int cursor;      // 迭代器指針（光標(biāo)），默認(rèn)指向集合0索引
    int lastRet = -1; // 記錄上一次調(diào)用next()返回的元素索引，初始值-1（表示未操作）
    int expectedModCount = modCount; // 記錄集合的修改次數(shù)（創(chuàng)建迭代器時(shí)的初始次數(shù)）

    // hasNext()原理：判斷指針是否到達(dá)集合末尾（cursor等于集合大小，說明無元素）
    public boolean hasNext() {
        return cursor != size;
    }

    // next()原理：獲取當(dāng)前指針元素，指針后移，并校驗(yàn)集合是否被修改
    public E next() {
        checkForComodification(); // 核心校驗(yàn)：判斷集合是否被非法修改
        int i = cursor; // 記錄當(dāng)前指針位置
        if (i >= size)
            throw new NoSuchElementException(); // 指針越界，拋異常
        Object[] elementData = ArrayList.this.elementData; // 獲取ArrayList底層數(shù)組
        if (i >= elementData.length)
            throw new ConcurrentModificationException(); // 并發(fā)修改異常
        cursor = i + 1; // 指針后移一位
        return (E) elementData[lastRet = i]; // 返回當(dāng)前元素，并更新lastRet
    }

    // 校驗(yàn)集合是否被修改：expectedModCount（迭代器記錄的次數(shù)） != modCount（集合實(shí)際次數(shù)）
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}