Java 控制流语句详解：break, continue, return 及标签的使用

break, continue, return 的区别及作用

在编程中，break, continue, 和 return 是常用的控制流语句，用于改变程序的执行顺序。本文将详细介绍这三个关键字的区别及作用，并通过代码示例进行说明。此外，还将介绍如何使用标签（label）来更灵活地控制多层循环的退出。

1. break

• 作用：立即终止当前循环或开关语句（switch）的执行。
• 特点：跳出最内层的循环或开关语句，继续执行循环或开关语句之后的代码。
• 适用场景：通常用于在满足某个条件时提前结束循环。

代码示例

for (int i = 0; i < 10; i++) {
    if (i == 5) {
    	// 当 i 等于 5 时，跳出循环
        break; 
    }
    // 输出: 0 1 2 3 4
    System.out.println(i);
}

2. continue

• 作用：跳过当前循环的剩余部分，直接开始下一次循环迭代。
• 特点：不终止整个循环，而是跳过本次循环的剩余部分，继续执行下一次循环。
• 适用场景：通常用于在满足某个条件时跳过当前循环的某些操作。

代码示例

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
    	// 当 i 是偶数时，跳过本次循环的剩余部分
        continue; 
    }
    // 输出: 1 3 5 7 9
    System.out.println(i);
}

3. return

• 作用：立即从当前方法返回，并可以返回一个值（如果方法有返回值）。
• 特点：终止当前方法的执行，返回到调用该方法的地方。
• 适用场景：通常用于在方法中返回结果或在满足某个条件时提前结束方法。

代码示例

public int findFirstEven(int[] numbers) {
    for (int i = 0; i < numbers.length; i++) {
        if (numbers[i] % 2 == 0) {
        	// 当找到第一个偶数时，返回该偶数并结束方法
            return numbers[i]; 
        }
    }
    // 如果没有找到偶数，返回 -1
    return -1; 
}

public static void main(String[] args) {
    int[] numbers = {1, 3, 5, 8, 10};
    int result = findFirstEven(numbers);
    // 输出: 8
    System.out.println(result); 
}

break, continue, return 在多层循环中的表现

在多层循环中，这些关键字的行为会有所不同，具体如下：

1. break

• 作用：仅终止最内层的循环。
• 特点：不会影响外层循环的执行。

代码示例

// 外层循环
for (int i = 0; i < 3; i++) { 
    System.out.println("外层循环: " + i);
    // 内层循环
    for (int j = 0; j < 3; j++) { 
        if (j == 1) {
        	// 当 j 等于 1 时，跳出内层循环
            break; 
        }
        System.out.println("  内层循环: " + j);
    }
}
// 输出:
// 外层循环: 0
//   内层循环: 0
// 外层循环: 1
//   内层循环: 0
// 外层循环: 2
//   内层循环: 0

2. continue

• 作用：仅跳过最内层循环的当前迭代，继续下一次迭代。
• 特点：不会影响外层循环的执行。

代码示例

// 外层循环
for (int i = 0; i < 3; i++) { 
    System.out.println("外层循环: " + i);
    // 内层循环
    for (int j = 0; j < 3; j++) { 
        if (j == 1) {
        	// 当 j 等于 1 时，跳过本次内层循环的剩余部分
            continue; 
        }
        System.out.println("  内层循环: " + j);
    }
}
// 输出:
// 外层循环: 0
//   内层循环: 0
//   内层循环: 2
// 外层循环: 1
//   内层循环: 0
//   内层循环: 2
// 外层循环: 2
//   内层循环: 0
//   内层循环: 2

3. return

• 作用：立即从当前方法返回，并可以返回一个值（如果方法有返回值）。
• 特点：终止当前方法的执行，包括所有嵌套的循环。

代码示例

public int findFirstEvenInNestedLoops(int[][] matrix) {
    // 外层循环
    for (int i = 0; i < matrix.length; i++) { 
        // 内层循环
        for (int j = 0; j < matrix[i].length; j++) { 
            if (matrix[i][j] % 2 == 0) {
            	// 当找到第一个偶数时，返回该偶数并结束方法
                return matrix[i][j]; 
            }
        }
    }
    // 如果没有找到偶数，返回 -1
    return -1; 
}

public static void main(String[] args) {
    int[][] matrix = {
        {1, 3, 5},
        {8, 10, 12},
        {7, 9, 11}
    };
    int result = findFirstEvenInNestedLoops(matrix);
    // 输出: 8
    System.out.println(result); 
}

使用标签（Label）控制多层循环的退出

在 Java 中，可以通过使用标签（label）来更灵活地控制多层循环的退出。标签可以用于 break 和 continue 语句，使它们能够跳出或跳过指定的循环层次。

1. 标签的基本语法

• 定义标签：在循环语句前加上一个标识符（标签），后跟一个冒号 :。
• 使用标签：在 break 或 continue 语句后加上标签名。

2. 使用标签的 break

• 作用：跳出指定标签的循环。
• 特点：可以跳出多层循环，而不仅仅是最内层的循环。

代码示例

// 定义外层循环的标签
outerLoop: 
for (int i = 0; i < 3; i++) {
    System.out.println("外层循环: " + i);
    // 定义内层循环的标签
    innerLoop: 
    for (int j = 0; j < 3; j++) {
        System.out.println("  内层循环: " + j);
        if (i == 1 && j == 1) {
        	// 跳出外层循环
            break outerLoop; 
        }
    }
}
// 输出:
// 外层循环: 0
//   内层循环: 0
//   内层循环: 1
//   内层循环: 2
// 外层循环: 1
//   内层循环: 0
//   内层循环: 1

在这个例子中，当 i == 1 且 j == 1 时，break outerLoop 语句会跳出外层循环 outerLoop，而不是仅仅跳出内层循环 innerLoop。

3. 使用标签的 continue

• 作用：跳过指定标签的当前迭代，继续下一次迭代。
• 特点：可以跳过多层循环的当前迭代，而不仅仅是最内层的循环。

代码示例

// 定义外层循环的标签
outerLoop: 
for (int i = 0; i < 3; i++) {
	// 输出外层循环的当前值
    System.out.println("外层循环: " + i); 
    innerLoop: // 定义内层循环的标签
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) {
        	// 当 i == 1 且 j == 1 时，跳过外层循环的当前迭代
            continue outerLoop; 
        }
        // 输出内层循环的当前值
        System.out.println("  内层循环: " + j); 
    }
}

// 输出结果:
// 外层循环: 0
//   内层循环: 0
//   内层循环: 1
//   内层循环: 2
// 外层循环: 1
//   内层循环: 0
// 外层循环: 2
//   内层循环: 0
//   内层循环: 1
//   内层循环: 2