Java Break and Continue

break and continue are jump statements that alter the normal top-to-bottom flow of a loop from inside its body. break exits the loop entirely, while continue skips only the rest of the current iteration and moves straight to the next one. Both make it possible to express "stop early" or "skip this one" logic without wrapping the whole loop body in a large conditional.

Beyond simple loops, Java also supports labeled break and labeled continue, which extend this control to nested loops — letting inner-loop code affect an outer loop directly, something an unlabeled break or continue cannot do.

Why it matters

break and continue let a loop stop or skip as soon as the answer is known, instead of running to the end and tracking extra flags. Used well they make search and filter loops shorter; used carelessly, especially in nested loops, they hide the path the code takes — so it pays to know exactly which loop each one affects.

The break Statement

An unlabeled break immediately terminates the nearest enclosing loop (for, while, or do-while) or switch statement, and execution resumes at the first statement after that loop or switch. It is commonly used to stop searching once a target has been found, avoiding unnecessary further iterations.

The continue Statement

continue skips the remaining statements in the current iteration of the nearest enclosing loop and jumps directly to the loop's update/condition check — in a for loop that means the update expression still runs before the condition is re-tested. It is useful for filtering out cases that should be skipped without nesting the rest of the loop body inside an if block.

Labeled break and continue

A label is an identifier followed by a colon placed immediately before a loop, such as search: before a for loop. break search; exits that specific labeled loop (even from inside a nested inner loop), and continue search; skips to the next iteration of that specific labeled loop rather than the innermost one. Labels are the only way to break or continue an outer loop directly from inside a nested loop without extra boolean flags.

Examples

public class BreakContinueDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                continue;
            }
            if (i > 7) {
                break;
            }
            System.out.println(i);
        }
    }
}

1
3
5
7

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

        search:
        for (int row = 0; row < matrix.length; row++) {
            for (int col = 0; col < matrix[row].length; col++) {
                if (matrix[row][col] == target) {
                    found = true;
                    System.out.println("Found at [" + row + "][" + col + "]");
                    break search;
                }
            }
        }
        System.out.println("Found: " + found);
    }
}

Found at [1][1]
Found: true

Exercise

Find the first number between 1 and 200 that is divisible by both 7 and 9, and stop searching as soon as you find it.

Expected output: 63

public class FirstCommonMultiple {
    public static void main(String[] args) {
        int found = -1;

        for (int i = 1; i <= 200; i++) {
            // TODO: when i is divisible by 7 and by 9, store it and stop the loop
        }

        System.out.println(found);
    }
}

public class FirstCommonMultiple {
    public static void main(String[] args) {
        int found = -1;

        for (int i = 1; i <= 200; i++) {
            if (i % 7 == 0 && i % 9 == 0) {
                found = i;
                break;
            }
        }

        System.out.println(found); // 63
    }
}

Quick quiz

Interview questions