Java流程控制——7.break和continue

目录

• Java中的break与continue
  • break语句：跳出循环
    • 基本用法示例
    • 嵌套循环中的break
  • continue语句：跳过本次循环
    • 基本用法示例
    • 嵌套循环中的continue
  • break与continue的对比
    • 关键区别示例
  • 场景案例
    • 场景1：查找元素
    • 场景2：过滤数据
  • 注意事项
  • 总结

---

Java中的break与continue

在循环结构中，有时需要根据特定条件改变循环的执行流程——提前退出循环或跳过当前循环的剩余部分。Java提供的break和continue语句正是实现这种精细控制的工具，它们能让循环结构更加灵活和高效。

break语句：跳出循环

break语句的作用是立即终止当前所在的循环，并跳出该循环体，继续执行循环之后的代码。它通常与if条件判断配合使用，在满足特定条件时提前结束循环。

基本用法示例

public class BreakExample {
    public static void main(String[] args) {
        int sum = 0;
        int i = 1;

        while (true) {  // 无限循环
            sum += i;
            if (i == 100) {
                break;  // 当i等于100时跳出循环
            }
            i++;
        }

        System.out.println("1到100的和为：" + sum);  // 输出5050
    }
}

在这个例子中，while(true)创建了一个理论上的无限循环，但通过break语句，我们在i达到100时成功终止了循环，避免了真正的无限循环。

嵌套循环中的break

在嵌套循环中，break语句只跳出它所在的那一层循环，不会影响外层循环：

public class NestedBreakExample {
    public static void main(String[] args) {
        // 外层循环
        for (int i = 1; i <= 3; i++) {
            System.out.println("外层循环 i = " + i);

            // 内层循环
            for (int j = 1; j <= 5; j++) {
                System.out.println("  内层循环 j = " + j);
                if (j == i) {
                    break;  // 只跳出内层循环
                }
            }

            System.out.println("内层循环结束");
        }
        System.out.println("外层循环结束");
    }
}

输出结果：

外层循环 i = 1
  内层循环 j = 1
内层循环结束
外层循环 i = 2
  内层循环 j = 1
  内层循环 j = 2
内层循环结束
外层循环 i = 3
  内层循环 j = 1
  内层循环 j = 2
  内层循环 j = 3
内层循环结束
外层循环结束

可以看到，break语句只终止了内层循环，外层循环仍然继续执行。

continue语句：跳过本次循环

continue语句的作用是提前结束当前次循环，直接进入下一次循环的判断条件。它不会终止整个循环，只是跳过当前循环中剩余的代码。

基本用法示例

public class ContinueExample {
    public static void main(String[] args) {
        int sum = 0;

        for (int i = 1; i <= 6; i++) {
            System.out.println("开始处理 i = " + i);

            if (i % 2 == 0) {  // 如果i是偶数
                continue;  // 跳过本次循环的剩余部分
            }

            sum += i;  // 只累加奇数
            System.out.println("结束处理 i = " + i);
        }

        System.out.println("1到6的奇数和为：" + sum);  // 输出25
    }
}

输出结果：

开始处理 i = 1
结束处理 i = 1
开始处理 i = 2
开始处理 i = 3
结束处理 i = 3
开始处理 i = 4
开始处理 i = 5
结束处理 i = 5
开始处理 i = 6
1到6的奇数和为：9

当i为偶数时，continue语句跳过了后续的累加操作和"结束处理"打印，直接进入下一次循环。

嵌套循环中的continue

与break类似，continue在嵌套循环中也只作用于它所在的那一层循环：

public class NestedContinueExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (j == 2) {
                    continue;  // 跳过内层循环的j=2的本次循环
                }
                System.out.println("i=" + i + ", j=" + j);
            }
        }
    }
}

输出结果：

i=1, j=1
i=1, j=3
i=2, j=1
i=2, j=3
i=3, j=1
i=3, j=3

可以看到，continue语句只跳过了内层循环中j=2的那次循环，对其他循环没有影响。

break与continue的对比

语句	作用	适用场景
break	终止当前循环，跳出循环体	满足条件时完全结束循环
continue	跳过当前循环的剩余部分，进入下一次循环	满足条件时跳过本次循环的部分操作

关键区别示例

public class BreakVsContinue {
    public static void main(String[] args) {
        System.out.println("使用break:");
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                break;
            }
            System.out.println(i);
        }

        System.out.println("\n使用continue:");
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                continue;
            }
            System.out.println(i);
        }
    }
}

输出结果：

使用break:
1
2

使用continue:
1
2
4
5

这个对比清晰展示了两者的区别：break在i=3时完全终止了循环，而continue只是跳过了i=3的输出，循环继续执行。

场景案例

场景1：查找元素

使用break在找到目标元素后立即终止循环，提高效率：

public class FindElement {
    public static void main(String[] args) {
        int[] numbers = {5, 12, 8, 3, 17, 9};
        int target = 8;
        int index = -1;

        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] == target) {
                index = i;
                break;  // 找到后立即退出循环
            }
        }

        if (index != -1) {
            System.out.println("找到元素 " + target + "，索引为：" + index);
        } else {
            System.out.println("未找到元素 " + target);
        }
    }
}

场景2：过滤数据

使用continue跳过不需要处理的数据：

public class FilterData {
    public static void main(String[] args) {
        String[] names = {"Alice", "Bob", "Charlie", "David", "Eve"};

        // 只处理长度大于3的名字
        for (String name : names) {
            if (name.length() <= 3) {
                continue;  // 跳过短名字
            }
            System.out.println("处理名字：" + name);
            // 此处可以添加复杂的处理逻辑
        }
    }
}

注意事项

1. 配合清晰的条件判断：break和continue通常与if语句配合使用，条件判断应清晰明确，避免模糊的逻辑。

2. 注意循环嵌套层次：在多层嵌套循环中，break和continue只作用于当前层，如需跳出多层循环，可使用标记（label）：

// 使用标记跳出多层循环
public class LabeledBreak {
    public static void main(String[] args) {
        outerLoop:  // 外层循环标记
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (i * j > 5) {
                    System.out.println("跳出外层循环");
                    break outerLoop;  // 跳出标记的外层循环
                }
                System.out.println("i=" + i + ", j=" + j);
            }
        }
    }
}

总结

• break：终止当前循环，完全跳出循环体
• continue：跳过当前循环的剩余部分，直接进入下一次循环