How Do break, continue, and Labeled Loops Work?

Both act on the innermost enclosing loop, and that is the detail people get wrong. break abandons the loop entirely and execution continues with the statement after it. continue abandons only the current iteration and the loop starts its next one, skipping whatever was left in the body after the continue.

Inside nested loops, break only leaves the inner loop; the outer loop carries on with its next iteration. The same is true of continue. That is why a break in a double loop frequently leaves you still looping over the outer dimension when you thought you had exited completely.

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                System.out.println("continue at i=" + i);
                continue;      // skip the rest of this iteration
            }
            if (i == 5) {
                System.out.println("break at i=" + i);
                break;         // leave the loop altogether
            }
            System.out.println("value " + i);
        }

        // In a nested loop, break only leaves the inner one.
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (j == 1) {
                    break;
                }
                System.out.println("i=" + i + " j=" + j);
            }
        }
    }
}

Two more points of precision. A break or continue inside a switch statement applies to the switch, not to any loop around it — so a break in a switch nested inside a for loop exits only the switch. And continue is not allowed inside a switch expression at all, since a switch expression must produce exactly one value and skipping part of the computation would make that ill-defined.

Java lets you put a label in front of a loop and then name that label in a break or continue. A labeled break jumps out of the labeled loop entirely, including any loops nested inside it. A labeled continue jumps to the next iteration of the labeled loop, skipping whatever remains of the inner loops for this round.

The label goes immediately before the loop keyword, and the break or continue names it after the keyword. The label must refer to a loop that encloses the break or continue — you cannot jump into a loop from outside it.

Where labeled break earns its keep is search-and-exit: a nested scan that should stop entirely as soon as it finds a match. Labeled continue earns its keep when the inner loop should be abandoned for the current outer iteration but the outer loop should carry on — skipping malformed rows in a matrix, for instance, rather than abandoning the whole scan.

Where you should be careful is that labels are a blunt instrument. In interviews, most people reach for a flag variable instead, and it is worth being able to defend both. A flag keeps the loop bodies free of unusual control flow but adds a mutable variable that has to be threaded through the code. A labeled break keeps the intent local and removes the flag, at the cost of introducing a construct that many reviewers dislike. For a single search in a two-level loop the labeled break is usually cleaner; for anything deeper, extracting the search into a method with an early return is clearer than either.

Java has two answers. The labeled break names the outer loop and jumps straight out of every level at once. The other answer, which is usually better in application code, is to extract the search into a method and return early, because a return leaves the method in one step rather than unwinding loop levels.

public class Main {
    public static void main(String[] args) {
        int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };

        search:
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                if (matrix[i][j] == 6) {
                    System.out.println("found 6 at row " + i + ", column " + j);
                    break search;   // leaves BOTH loops at once
                }
            }
        }

        // Labeled continue: abandon this row, move on to the next one.
        int[][] grid = { {1, 2}, {0, 0}, {3, 4} };
        outer:
        for (int[] row : grid) {
            for (int cell : row) {
                if (cell == 0) {
                    continue outer;
                }
            }
            System.out.println("complete row: " + java.util.Arrays.toString(row));
        }

        // The method-extraction version is often the clearest of all.
        System.out.println("method version: " + find(matrix, 6));
    }

    static String find(int[][] matrix, int target) {
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                if (matrix[i][j] == target) {
                    return "found at " + i + "," + j;
                }
            }
        }
        return "not found";
    }
}

Notice the difference in output between the two labeled forms. The labeled break stops the whole scan the moment it finds the target, printing one line. The labeled continue skips only the row that contains a zero, so both complete rows are printed.

The engineering judgement behind the choices: a labeled break is fine for a two-level search but becomes hard to follow once loops are three deep. Extracting the search into a method with a return gets you the same early exit, keeps the loops flat and unlabelled, and makes the search independently testable. In production code that last point is often what tips the decision.