We're taking a leap today to learn break and continue, our control tools in Java loops. break works as an exit, allowing you to leave a loop early, while continue assists in skipping unneeded iterations. Let's get started!

Think of the break command as representing the moment the music stops during a game of musical chairs, prompting you to exit the loop. It ends the loop regardless of the loop's original condition.

Here is a quick example:

Java
Copy
1for (int i = 0; i < 10; i++) {
2    if(i == 7) { // When `i` reaches 7
3        System.out.println("7 found! Break!"); // Message before the break
4        break; // Terminating the loop
5    }
6    System.out.println("Number: " + i); // Print i until we hit "break"
7}
8// Prints:
9// Number: 0
10// Number: 1
11// Number: 2
12// Number: 3
13// Number: 4
14// Number: 5
15// Number: 6
16// 7 found! Break!

Our loop operates on numbers from 0 to 6 and breaks when it reaches 7, taking an early exit and skipping all remaining iterations.

The keyword continue in Java is analogous to skipping a boring view during a walk. It disregards the current loop iteration and jumps ahead to the next one.

Here is an example:

Java
Copy
1for (int j = 1; j <= 10; j++) {
2    if (j == 4 || j == 7) { // Skip the 4th and 7th buildings
3        continue;
4    }
5    System.out.println("Admiring building number: " + j); // Continue with the rest
6}
7// Prints:
8// Admiring building number: 1
9// Admiring building number: 2
10// Admiring building number: 3
11// Admiring building number: 5
12// Admiring building number: 6
13// Admiring building number: 8
14// Admiring building number: 9
15// Admiring building number: 10

Our output presents admiration logs for all buildings except numbers 4 and 7, which our continue statement omits.

Nested loops, like a spiral galaxy with numerous orbits, are loops within loops. Even in these spinning spirals, break and continue function distinctly. It is important to mention that both break and continue will exit/skip only the corresponding inner loop, not affecting the outer loop. Let's illustrate this with a couple of examples.

Consider a nested loop running on a 5x5 grid.

Java
Copy
1for (int i = 1; i <= 5; i++) {
2    System.out.print(i + ": ");
3    for (int j = 1; j <= 5; j++) {
4        if (i == 3 && j == 3) {
5            // break the inner loop
6            break;
7        }
8        System.out.print(j + " ");
9    }
10    System.out.println();
11}
12// Prints:
13// 1: 1 2 3 4 5
14// 2: 1 2 3 4 5
15// 3: 1 2
16// 4: 1 2 3 4 5
17// 5: 1 2 3 4 5

Here, break ends the inner loop when i and j both equal 3. Thus, when i becomes 3, the inner loop runs only up to j = 2 and then breaks. However, the outer loop continues until i = 5.

Meanwhile, let's introduce 'continue' in a similar setup.

Java
Copy
1for (int i = 1; i <= 5; i++) {
2    System.out.print(i + ": ");
3    for (int j = 1; j <= 5; j++) {
4        if (i == 3 && j == 3) {
5            continue;
6        }
7        System.out.print(j + " ");
8    }
9    System.out.println();
10}
11// Prints:
12// 1: 1 2 3 4 5
13// 2: 1 2 3 4 5
14// 3: 1 2 4 5
15// 4: 1 2 3 4 5
16// 5: 1 2 3 4 5

continue, once it meets the i == 3 && j == 3 condition, skips the rest of the code inside its loop and instantly moves to the next iteration. In this case, it means we skip printing j when both i and j are equal to 3.

Well done! You've learned the break and continue commands, giving you control over Java loops. Practice is essential for mastering these concepts. Let's embark on some exercises to enhance your skills. Enjoy your practice session!