Table of Contents
1. Introduction
The break keyword in Java is primarily used in two contexts: within loops (for, while, and do-while) and in switch statements. Its main purpose is to terminate the loop or switch statement and transfer control to the statement immediately following the loop or switch.
2. Syntax
The syntax of the break statement is very simple. We just need to use the break keyword followed by a semicolon (;). We can also use labeled break statements, which we will explore later in the article.
|
1 2 3 4 5 6 7 8 9 |
while (condition) { //statement(s) if(break-condition) break; //statement(s) } //statement(s) |
Here, the while loop is terminated as soon as the break statement is executed, transferring the flow to the statements following the loop or switch.
3. Break Statement Example
To illustrate the use of the break statement, let’s consider a simple scenario: We want to search for a specific number in an array and stop the search once we find it.
Here is an example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
int[] numbers = {1, 2, 3, 4, 5}; int target = 3; boolean found = false; for (int number : numbers) { if (number == target) { found = true; break; // Exit the loop once the target is found } } System.out.println("Target found: " + found); |
|
1 2 3 |
Target found: true |
In this example, the break statement is used to exit the loop immediately after the target number is found, preventing the loop from iterating over the rest of the array. This enhances performance, especially in scenarios where the array is large, and the target is located near the beginning.
The break statement only terminates the loop in which it is present. If this loop is nested within another loop, the outer loop will not terminate.
Let’s see with the help of example:
Given a 2D array, we need to find an element within it. As soon as we find the element, we must stop the search.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
int[][] numbers = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; int target = 5; for (int i = 0; i < numbers.length; i++) { for (int j = 0; j < numbers[i].length; j++) { if (numbers[i][j] == target) { System.out.println("Target " + target + " found at [" + i + "][" + j + "]"); break; // Break out of the inner loop } } System.out.println("Inside Outer Loop at [" + i + "][" + j + "]"); } if (!found) { System.out.println("Target " + target + " not found."); } |
Output:
|
1 2 3 4 5 6 7 8 9 10 |
Inside Outer Loop at [0][0] Inside Outer Loop at [0][1] Inside Outer Loop at [0][2] Inside Outer Loop at [1][0] Target 5 found at [1][1] Inside Outer Loop at [2][0] Inside Outer Loop at [2][1] Inside Outer Loop at [2][2] |
As we can see, even though we found the target element, the outer loop continued its iterations. To stop the outer loop, we could use a boolean flag named found and utilize it to break out of the outer loop.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
int[][] numbers = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; int target = 5; boolean found = false; for (int i = 0; i < numbers.length; i++) { for (int j = 0; j < numbers[i].length; j++) { if (numbers[i][j] == target) { found = true; System.out.println("Target " + target + " found at [" + i + "][" + j + "]"); break; // Break out of the inner loop } } if (found) { break; // Optional: Break out of the outer loop if needed } } if (!found) { System.out.println("Target " + target + " not found."); } |
|
1 2 3 |
Target 5 found at [1][1] |
4. Using Break in a While Loop
The break statement works similarly in a while loop, providing a way to exit based on a condition evaluated during the execution of the loop. Similarly, the break statement in a do-while loop works in the same manner as in a while loop.
Example:
|
1 2 3 4 5 6 7 8 9 10 |
int count = 0; while (count < 10) { if (count == 5) { break; // Exit the loop when count is 5 } System.out.println("Count: " + count); count++; } |
Output:
|
1 2 3 4 5 6 7 |
Count: 0 Count: 1 Count: 2 Count: 3 Count: 4 |
In this example, the loop is terminated as soon as the value of i reaches 5. This shows how the break statement can be used to exit a loop early, avoiding unnecessary iterations.
5. Using Break in a Switch Statement
In a switch statement, the break statement is used to terminate a case, ensuring that the program does not continue to execute the following cases. It ensures that once the case condition is met, subsequent cases won’t be executed.
Example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
char grade = 'B'; switch (grade) { case 'A': System.out.println("Excellent"); break; // Exit the switch statement case 'B': System.out.println("Good"); break; // Exit the switch statement case 'C': System.out.println("Average"); break; // Exit the switch statement default: System.out.println("Grade not recognized"); } |
Output:
|
1 2 3 |
Good |
6. Labeled Break Statement
In addition to the simple break statement that terminates the nearest enclosing loop or switch statement, Java provides a labeled break statement. This allows for the termination of an outer loop when a break statement is executed within a nested loop, offering greater control over complex loop structures.
A label is an identifier followed by a colon (:) placed before a loop or block statement. When a break statement specifies a label, control is transferred out of the labeled statement, not just the immediate loop. This capability is particularly useful in nested loops where a condition in an inner loop requires exiting one or more outer loops.
Syntax of Labeled Break:
|
1 2 3 4 5 6 7 8 |
labelName: for(initialization; condition; update) { // Inner loop or statements if(someCondition) { break labelName; // Breaks out of the loop marked with labelName } } |
Let’s see with the help of example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; int target = 5; boolean found = false; search: for (int i = 0; i < matrix.length; i++) { for (int j = 0; j < matrix[i].length; j++) { if (matrix[i][j] == target) { found = true; System.out.println("Found " + target + " at [" + i + "][" + j + "]"); break search; // Exits the outer loop labeled 'search' } } } if (!found) { System.out.println(target + " not found in the matrix."); } |
Output:
|
1 2 3 |
Found 5 at [1][1] |
As we can see, as soon as the target element was found, we invoked break search; and that caused the exit from the outer for loop labeled search.
7. Usage Scenarios
- Exiting a Loop: To terminate a loop when a certain condition is met, improving efficiency by avoiding unnecessary iterations.
- Switch Statement: To end a case in a
switchstatement, ensuring that only the code within the matched case is executed. - Nested Loops: In nested loops, a
breakwill only exit the innermost loop in which it is placed.
8. Conclusion
The break statement is a fundamental control structure in Java that allows for more efficient and readable code. By providing a means to exit loops and terminate switch cases prematurely, it enhances the performance of Java applications and ensures that resources are not wasted on unnecessary operations.
