List<String> list = Arrays.asList("A", "B", "C", "D");
list.forEach(str -> {
    if (str.equals("C")) {
        break; // 編譯報(bào)錯(cuò)：Break outside switch or loop
    }
    System.out.println(str);
});

import java.util.Arrays;
import java.util.List;
// 自定義運(yùn)行時(shí)異常，用于中斷 forEach 遍歷
class BreakForEachException extends RuntimeException {}
public class ForEachBreakDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C", "D");
        try {
            list.forEach(str -> {
                if (str.equals("C")) {
                    // 拋出異常，中斷遍歷
                    throw new BreakForEachException();
                }
                System.out.println("遍歷元素：" + str);
            });
        } catch (BreakForEachException e) {
            System.out.println("遍歷已終止（捕獲自定義異常）");
        }
    }
}

import java.util.Arrays;
import java.util.List;
public class ForEachBreakDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C", "D");
        // 流式編程：遍歷到 "C" 之前的元素（不包含 "C"），實(shí)現(xiàn)類似 break 的效果
        list.stream()
            .takeWhile(str -> !str.equals("C")) // Java 9+ 支持：保留滿足條件的元素，直到第一個(gè)不滿足條件的元素出現(xiàn)
            .forEach(str -> System.out.println("遍歷元素：" + str));
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
public class ForEachBreakDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C", "D");
        // 找到第一個(gè)需要退出的元素索引
        int breakIndex = list.indexOf("C");
        if (breakIndex == -1) breakIndex = list.size();
        // 遍歷到該索引之前的元素
        IntStream.range(0, breakIndex)
            .mapToObj(list::get)
            .forEach(str -> System.out.println("遍歷元素：" + str));
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
public class ForEachBreakDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C", "D");
        // 定義原子布爾標(biāo)志位（線程安全，單線程場(chǎng)景也可使用普通布爾變量+volatile）
        AtomicBoolean continueFlag = new AtomicBoolean(true);
        list.forEach(str -> {
            // 先判斷標(biāo)志位，為 false 則跳過(guò)當(dāng)前及后續(xù)元素
            if (continueFlag.get()) {
                if (str.equals("C")) {
                    // 設(shè)置標(biāo)志位為 false，終止后續(xù)遍歷
                    continueFlag.set(false);
                    return; // 跳出當(dāng)前 Lambda 回調(diào)方法（類似 continue，而非 break）
                }
                System.out.println("遍歷元素：" + str);
            }
        });
    }
}

import java.util.Arrays;
import java.util.List;
public class NormalLoopDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C", "D");
        // 傳統(tǒng) for 循環(huán)（索引遍歷）
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(i);
            if (str.equals("C")) {
                break; // 終止整個(gè)循環(huán)（后續(xù)元素不再遍歷）
            }
            if (str.equals("B")) {
                continue; // 跳過(guò)當(dāng)前元素（不執(zhí)行后續(xù)邏輯，直接進(jìn)入下一次循環(huán)）
            }
            System.out.println("遍歷元素：" + str);
        }
        // 增強(qiáng) for 循環(huán)（for-each）
        for (String str : list) {
            if (str.equals("D")) {
                return; // 直接退出當(dāng)前方法（不僅終止循環(huán)，整個(gè) main 方法都結(jié)束）
            }
            System.out.println("遍歷元素（for-each）：" + str);
        }
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.Iterator;
public class WhileLoopDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C", "D");
        Iterator<String> iterator = list.iterator();
        // while 循環(huán)（配合迭代器）
        while (iterator.hasNext()) {
            String str = iterator.next();
            if (str.equals("C")) {
                break; // 終止 while 循環(huán)
            }
            System.out.println("遍歷元素（while）：" + str);
        }
    }
}

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("A");
        list.add("B");
        list.add("C");
        list.add("D");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            if (str.equals("C")) {
                iterator.remove(); // 刪除當(dāng)前元素（"C"）
                break; // 終止遍歷
            }
            System.out.println("遍歷元素（迭代器）：" + str);
        }
        System.out.println("刪除后的集合：" + list);
    }
}

import java.util.Arrays;
import java.util.List;
public class StreamShortCircuitDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C", "D");
        // anyMatch()：存在任意一個(gè)元素滿足條件，立即返回 true，終止后續(xù)遍歷
        boolean hasC = list.stream()
            .peek(str -> System.out.println("遍歷元素（stream）：" + str)) // 僅用于打印遍歷過(guò)程
            .anyMatch(str -> str.equals("C"));
        System.out.println("集合中是否存在 'C'：" + hasC);
    }
}