Break statement in java is used to terminate loops and switch case statements immediately without checking the test expression and the control of the program moves to the next statement following the loop or switch case statement. Use of break statement interrupts the normal execution sequence of loops or switch statement whenever specified condition is true.
We can use break statement to terminate for loop, while loop, do-while loop and swtch case statement.
In case of nested loop, if break statement is encountered inside inner loop then it will only terminate the execution of inner loop. In general, it breaks the execution of loop enclosing it.
In this comprehensive tutorial, we will explore the various use cases, syntax, and best practices of the break statement in Java. By the end of this tutorial, you'll have a solid understanding of how to wield the break statement effectively in your Java programs.
Syntax and Variations of the Break Statement
- Labeled Break : A labeled break statement allows you to specify which loop or switch statement to exit when dealing with nested constructs. The label is placed before the loop or switch, followed by a colon.
outerLoop: // Label for the outer loop for (int i = 1; i <= 3; i++) { for (int j = 1; j <= 3; j++) { System.out.println("i: " + i + ", j: " + j); if (/* some condition */) { System.out.println("Breaking from both loops."); break outerLoop; // Exit both loops } } }In this example, outerLoop: is the label, and break outerLoop; exits both the outer and inner loops. - Unlabeled Break : An unlabeled break statement is used to exit the innermost loop or switch statement without specifying a label.
for (int i = 1; i <= 5; i++) { for (int j = 1; j <= 5; j++) { if (/* some condition */) { System.out.println("Exiting inner loop."); break; // Exit the inner loop } } }In this example, the unlabeled break statement exits only the inner loop without affecting the outer loop.
Break statement inside for loop
When a break statement is executed inside for loop, it terminates for loop immediately and program control resumes at next statement after for loop.
for (initialization; condition; update) {
statements;
if(condition to break) {
break;
}
statements;
}
Break statement in for loop example program
public class ForLoopBreakStatement {
public static void main(String[] args) {
int count;
for (count = 0; count < 10; count++) {
if (count == 4) {
break;
}
System.out.println(count);
}
}
}
Output
0 1 2 3
Break statement inside while loop
When a break statement is executed inside while loop, it terminates while loop immediately and program control resumes at next statement after while loop.
while (condition) {
statements;
if(condition to break) {
break;
}
statements;
}
Break statement in while loop example program
public class WhileLoopBreakStatement {
public static void main(String[] args) {
int count = 0;
while (count < 10) {
if (count == 4) {
break;
}
System.out.println(count);
count++;
}
}
}
Output
0 1 2 3
Break statement inside do-while loop
When a break statement is executed inside do-while loop, it terminates do-while loop immediately and program control resumes at next statement after do-while loop.
do {
statements;
if(condition to break) {
break;
}
statements;
} while (condition);
Break statement in do-while loop example program
public class DoWhileLoopBreakStatement {
public static void main(String[] args) {
int count = 0;
do {
if (count == 4) {
break;
}
System.out.println(count);
count++;
} while (count < 10);
}
}
Output
0 1 2 3
Break statement in nested loop
In case of nested loop, if break statement is encountered it will only terminate the execution of loop enclosing it.
- If break statement is encountered inside inner loop then it will only terminate the execution of inner loop.
- If break statement is encountered inside outer loop then it will terminate the execution of outer loop.
public class BreakNestedLoop {
public static void main(String[] args) {
int i, j;
for (i = 0;i < 5;i++) { // outer loop
for (j = 0;j < 5;j++) { // inner loop
if (i == j) {
System.out.println("i="+ i +",j="+ j);
break; // terminates inner loop only
}
}
}
}
}
Output
i=0,j=0 i=1,j=1 i=2,j=2 i=3,j=3 i=4,j=4
Break statement inside switch statement
When a break statement is encountered inside switch case, it terminates switch case statement and program control resumes at next statement after switch statement block.
The break statement is optional in switch statement. The break statement at the end of each case block cause switch statement to terminate.
public class BreakSwitchStatement {
public static void main(String[] args) {
int number = 2;
switch (number) {
case 1:
System.out.println("One");
break;
case 2:
System.out.println("Two");
break;
case 3:
System.out.println("Three");
break;
default:
System.out.println("Default");
}
}
}
Output
Two
If break statement is not used inside case code block then all statements below that case block will also get executed until it found a break statement or end of switch statement.
public class NoBreakSwitchStatement {
public static void main(String[] args) {
int number = 2;
switch (number) {
case 1:
System.out.println("One");
case 2:
System.out.println("Two");
case 3:
System.out.println("Three");
default:
System.out.println("Default");
}
}
}
Output
Two Three Default
Best Practices for Using the Break Statement
- Use Break Sparingly : While the break statement is a powerful tool, excessive use can lead to code that is hard to understand and maintain. Use it judiciously and consider alternative approaches, such as restructuring your loops or using boolean flags, when appropriate.
- Provide Clear Conditions : When using the break statement, ensure that the conditions triggering the break are clear and well-documented. This helps improve code readability and makes it easier for others (or yourself) to understand the logic.
- Consider Alternative Control Flow : In some cases, the break statement can be replaced with alternative control flow constructs, such as return statements or boolean flags. Consider these alternatives to improve code structure and maintainability.
- Use Labels Judiciously : While labeled breaks can be useful in breaking out of nested constructs, excessive use of labels can make the code harder to read. Use labels judiciously and consider refactoring code to reduce the need for labeled breaks.
- Document Labeled Breaks : When using labeled breaks, provide comments documenting the purpose of the label and break statement. This helps improve code readability, especially when dealing with complex nested constructs.
Conclusion
The break statement in Java is a versatile and powerful tool for controlling the flow of your programs. Whether you need to exit a loop prematurely, break out of nested constructs, or terminate the execution of a switch statement, the break statement provides an effective solution.
By understanding the syntax, variations, and best practices associated with the break statement, you can use it judiciously to improve the readability and maintainability of your code. Consider alternative control flow constructs, such as boolean flags and function encapsulation, when appropriate, and provide clear documentation for labeled breaks.
As you continue to develop your Java programming skills, the break statement will become a valuable part of your programming toolkit, allowing you to write more efficient and expressive code.