Sometimes, it might be necessary to either stop a loop prematurely—without returning from a method—or skip over an iteration of a loop.
It is for this reason that Java has two special keywords: break (for the former
case), and continue (for the latter).
Suppose we want to exit a loop early. The break keyword
would be used to do that, like so:
public class BreakExample {
public static void
main(String[] args) {
for (int i =
1; i <= 10; i++) {
if (i ==
5) {
break;
// Exit the loop when i is 5
}
System.out.println("i = " + i);
}
System.out.println("Loop ended.");
}
}
(Never mind that, in this instance, the loop was written very badly—why loop
from 1 to 10, if you’re going to break out of the loop and stop it completely,
at 5? Poor design as this may be, it serves our purpose of illustrating how break
is used.)
This works for any loop—even those for which the index is not exposed (the
for-each/enhanced-for loop):
public class BreakForEachExample {
public static void
main(String[] args) {
String[]
laptops = {"Windows", "Samsung", "Apple",
"Dell", "Asus"};
for (String
laptop : laptops) {
if
(laptop.equals("Apple")) {
System.out.println("Yes, we want an Apple company laptop");
break;
// Exit the loop when "Apple" is found
}
}
}
}
The “continue” keyword, meanwhile, keeps the loop running, but skips over one
particular iteration.
Here, we see continue used in a while loop—just to drive home the point that both
these keywords can be used (meaning the same thing), regardless of what
particular loop they’re in: continue skips one, break comes out.
public class ContinueWhileExample {
public static void
main(String[] args) {
int i = 0;
while (i <
5) {
i++;
if (i ==
3) {
continue; // Skip the rest of the loop when i is 3
}
System.out.println("i = " + i);
}
}
}
Now, that’s all well and good if all we have is one loop to deal with—if that’s
true, then the behavior of these breakpoints is straightforward—but what
happens if we have nested loops, that is, loops inside loops, inside loops,
inside loops…?
This, for example, is a nested loop:
public class NestedLoopExample {
public static void
main(String[] args) {
for (int i =
1; i <= 3; i++) { // Outer loop for rows
for (int j
= 1; j <= 5; j++) { // Inner loop for columns
System.out.print("* ");
}
System.out.println(); // Move to the next line after each row
}
}
}
For each of the 3 rows, the program prints 5 * characters—producing something like
*****
*****
*****
If someone were to break or continue in a situation like this, where there are
nested loops—which can be of mixed types (for inside while, while inside
do-while, indexed-for inside for-each, while inside for-each, etc.)—break and
continue only apply to the innermost loop in which they could:
For example, the following code:
public class NestedLoopBreakExample {
public static void
main(String[] args) {
for (int i =
1; i <= 3; i++) { // Outer loop
for (int j
= 1; j <= 5; j++) { // Inner loop
if (j
== 3) {
break; // Exit the inner loop when j is 3
}
System.out.println("i = " + i + ", j = " + j);
}
}
}
}
has this output:
i = 1, j = 1
i = 1, j = 2
i = 2, j = 1
i = 2, j = 2
i = 3, j = 1
i = 3, j = 2
But if we use “continue” in the outer loop, then something like this might happen:
public class OuterContinueExample {
public static void
main(String[] args) {
for (int i =
1; i <= 3; i++) { // Outer loop
if (i ==
2) {
continue; // Skip the rest of this outer loop iteration when i is 2
}
for (int j
= 1; j <= 3; j++) { // Inner loop
System.out.println("i = " + i + ", j = " + j);
}
}
}
}
i = 1, j = 1
i = 1, j =
2
i = 1, j =
3
i = 3, j =
1
i = 3, j =
2
i = 3, j = 3
Both break and continue are vitally important logical flow
controllers—so be sure you understand how each works (and is different from the
other!). Don’t just stick to these code examples; write your own, or modify
these, and see how the behavior changes as you make changes to your code.
No comments:
Post a Comment