Labeled Statement in Java: Labeled Break and Continue With Examples

The label follows the same rules as a variable name: letters, digits, _ and $; it can’t start with a digit; and it can’t be a keyword. Labels live in their own namespace, so a label and a variable can even share a name (shown later). Choose a name that says what the loop does: pairSearch: tells the reader more than outer:.

You can put the label on the same line as the loop (pairSearch: for (...)) or on the line above. Both compile the same way.

Why Does a Plain break Fall Short in Nested Loops?

A plain break leaves only the innermost loop. In a search, that means the outer loop keeps going after the answer is found.

Here we look for two numbers that add up to 10:

Code (Java 21):

Output:

Pair: 8 + 2Comparisons: 9

Labeled Break in Java: Exit Nested Loops in One Step

Label the outer loop and name it in the break:

Code (Java 21):

Output:

Pair: 3 + 7 (indexes 0 and 4)Comparisons: 4

The variables foundI and foundJ were declared before the labeled loop, so they’re still readable after it. Always store what you found before jumping out.

A plain break returns control to the outer loop, which keeps running. A labeled break jumps straight to the first statement after the labeled loop

Labeled Break With Three Nested Loops

The label works at any depth. Here, break lockSearch; leaves three loops at once:

Code (Java 21):

Output:

Code found: 247Attempts: 248

Labeled Continue in Java: Skip to the Next Outer Iteration

A labeled continue abandons the rest of the current outer iteration, including any code after the inner loop, and starts the next one.

Here a student who fails any subject is skipped entirely:

Code (Java 21):

Output:

Asha: passed, total = 225Ravi: failed subject 2, skipped
Meena: passed, total = 181

What Goes Wrong With a Plain continue Here?

Swap in a plain continue, and it only skips the failing subject:

Code (Java 21):

Output:

Asha: passed, total = 225Ravi: passed, total = 145
Meena: passed, total = 181

Labeled Continue With a While Loop

Labels work on while and do-while loops too. As always with while loops, update the counter before any continue:

Code (Java 21):

Output:

row 1, col 1row 2, col 1
row 3, col 1
done

Does Java Have goto?

No. goto is a reserved word in Java that does nothing; trying to use it is a compile error:

Compiler output (Java 21):

 GotoAttempt.java:5: error: illegal start of expression        goto start;
        ^
GotoAttempt.java:5: error: not a statement
        goto start;
             ^
2 errors

Labeled break and continue are deliberately limited. They can only leave, or move to the next pass of, a statement that encloses the jump. You can’t jump backward, sideways, or into another block. That limit is what makes them safe, unlike C’s goto.

Labeling a Block (Not Just a Loop)

Any statement can be labeled, including a plain { } block. A labeled break then exits the block early, which is a compact way to stop a sequence of checks.

Code (Java 21):

Output:

ravi_21 -> valida -> too short
meena! -> invalid characters

Alternatives: Flag Variable vs Method With return

Labels aren’t the only way to stop nested loops. Here are the two common alternatives, solving the same pair search.

Alternative 1: A Boolean Flag

Code (Java 21):

Output:

 Pair: 3 + 7

Alternative 2: Extract a Method and return

Code (Java 21):

Output:

Pair: 3 + 7findPair(nums, 100) = null

return exits any number of nested loops, and the method name documents the intent. You’ll learn methods properly in the Methods lessons.

Performance: all four compile to ordinary jumps, so labels have no extra runtime cost. Choose based on readability.

Label Scope and Naming Rules

1. A label applies only to the statement directly after it, and is visible only inside that statement.
2. You can’t reuse a label name for a statement nested inside another statement with the same label.
3. You can reuse a name for two separate statements, one after the other.
4. A label and a variable may share a name; they don’t clash.

Code (Java 21):

Output:

first scan: 0second scan: 0
second scan: 1
variable outer = 99

Common Mistakes With Labeled Statements

Mistake 1: Using a Label Outside Its Statement

Compiler output (Java 21):

 OutOfScope.java:8: error: undefined label: rows            break rows;
            ^
1 error

Mistake 2: Reusing a Label on a Nested Loop

Compiler output (Java 21):

 DuplicateLabel.java:5: error: label outer already in use            outer:
            ^
1 error

Mistake 3: continue With a Block Label

Compiler output (Java 21):

 ContinueBlock.java:6: error: not a loop label: check                continue check;
                ^
1 error

continue means “next iteration”, and only loops have iterations. Use break check; for a block.

Mistake 4: Using a Plain continue When You Meant the Outer Loop

As the PlainContinueWrong example shows, this compiles and runs but gives a wrong result. Whenever an inner-loop condition should skip a whole outer item, use continue outerLabel;.

Mistake 5: Vague Label Names and Too Many Labels

outer: and loop1: say nothing about the loop’s purpose. If you need more than one or two labels in a method, extract a method instead.

Best Practices

1. Reach for a label only when a plain break or continue can’t do the job, which means nested loops.
2. Name labels after their purpose: pairSearch:, studentLoop:, slotSearch:.
3. Declare result variables before the labeled loop and set them before jumping.
4. Prefer extracting a method with return when the search has one clear result.
5. Keep labeled loops short enough that the label and its break fit on one screen.
6. In labeled while loops, update the loop state before any continue label.

Real-World Example: Find the First Free Period in a Timetable

Code (Java 21):

Output:

 First free slot: Wed, period 2

Practice Problems

1. Easy: In a 3×3 grid of numbers, find the first number greater than 50 and print its row and column, using a labeled break.
2. Easy: Print the pairs (i, j) for i, j in 1–4, but move to the next i as soon as j > i. Hint: continue outerLabel.
3. Medium: Given words in a 2D array (sentences × words), print only the sentences that contain no word longer than 6 letters. Hint: labeled continue to skip a sentence.
4. Medium: Rewrite Practice Problem 1 as a method that returns the position (or null) instead of using a label.
5. Medium: Find three numbers in an array that add up to a target using three nested loops, and stop all loops at the first match.

Try them in the ExamAdda online compiler.

Interview Questions on Labeled Break and Continue

1. What does a label do by itself?
Nothing. It only has an effect when a break label; or continue label; inside the labeled statement refers to it.

2. Difference between plain and labeled break?
A plain break exits only the innermost loop or switch; a labeled break exits the named enclosing statement, however deep the jump is nested.

3. Difference between labeled break and labeled continue?
A labeled break leaves the named loop completely; a labeled continue ends the current iteration of the named loop and starts its next one.

4. Does Java support goto?
No. goto is a reserved but unused keyword. Labeled break and continue can only exit or continue an enclosing statement.

5. Can you label a block or an if statement?
Yes, any statement can be labeled, and break label; exits it. continue label; works only with loops (“not a loop label” otherwise).

6. Do labeled jumps slow the program down?
No. They compile to ordinary jump instructions; the only cost is readability.

7. What alternatives exist to labeled break?
A boolean flag checked by the outer loop, or moving the loops into a method and using return, which is usually the clearest.

8. Can two loops use the same label name?
Yes if they’re one after the other; no if one is nested inside the other (“label … already in use”).

Article Summary

• A label (name:) placed before a loop lets break name; and continue name; control that outer loop from an inner one.
• A labeled break exits the named loop at any depth; a labeled continue skips to the named loop’s next iteration.
• Java has no goto; labeled jumps can only target statements that enclose them, and the compiler enforces label scope.
• Labels have no runtime cost, but a method with return or a flag is often clearer.
• Use descriptive label names, store results before jumping, and update while-loop counters before continue.

Conclusion

Labeled break and continue solve one specific problem: controlling an outer loop from deep inside nested loops. Use them when that is exactly what you need, name the label after its purpose, and consider a method with return when the search has a single clear answer. Next in the series, you’ll study decision-making in If-Else Statements in Java. Meanwhile, sharpen your loop skills with ExamAdda practice questions.

Previous lesson: Break and Continue in Java
Next lesson: If-Else Statements in Java

References

• Oracle Java Tutorials: Branching Statements
• Java Language Specification (Java SE 21), Chapter 14: Blocks, Statements, and Patterns