Nested Loops

Understanding Nested Loops and Control Statements in Java

In Java programming, loops are fundamental constructs that allow us to execute a block of code multiple times. Sometimes, you may need to use a loop inside another loop to solve more complex problems. This concept is known as a nested loop. In this blog, we will explore the different types of nested loops and control statements in Java that help manage the flow of these loops.

What is a Nested Loop?

A nested loop occurs when one loop is placed inside another loop. The inner loop executes completely every time the outer loop executes once. Nested loops are particularly useful for tasks involving multi-dimensional data structures or when dealing with repetitive tasks that require multiple levels of iteration.

There are three primary types of nested loops in Java:

1. Nested for Loop: When a for loop is used inside another for loop, it's called a nested for loop. This type of loop is commonly used when dealing with multi-dimensional arrays or grids.In this example, the inner for loop runs completely for each iteration of the outer for loop, creating a grid of stars.

public class NestedForLoopExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 3; i++) { // Outer loop
            for (int j = 1; j <= 3; j++) { // Inner loop
                System.out.print("* "); // Prints star
            }
            System.out.println(); // Moves to the next line after inner loop
        }
    }
}

2. Nested while Loop: A while loop inside another while loop is known as a nested while loop. This structure is useful when the number of iterations is not predetermined. This example prints a grid of hashes, similar to the nested for loop example but using while loops.

public class NestedWhileLoopExample {
    public static void main(String[] args) {
        int i = 1; // Outer loop control variable
        while (i <= 3) { // Outer loop
            int j = 1; // Inner loop control variable
            while (j <= 3) { // Inner loop
                System.out.print("# "); // Prints hash
                j++;
            }
            System.out.println(); // Moves to the next line after inner loop
            i++;
        }
    }
}

3. Nested do-while Loop: A do-while loop inside another do-while loop is referred to as a nested do-while loop. This type ensures that the code block is executed at least once before the condition is checked.

public class NestedDoWhileLoopExample {
    public static void main(String[] args) {
        int i = 1; // Outer loop control variable
        do {
            int j = 1; // Inner loop control variable
            do {
                System.out.print("@ "); // Prints at symbol
                j++;
            } while (j <= 3); // Inner loop condition
            System.out.println(); // Moves to the next line after inner loop
            i++;
        } while (i <= 3); // Outer loop condition
    }
}

4. In this example, the do-while loops create a grid of at symbols, with each inner loop iteration executed for every outer loop iteration.

Control Statements in Loops

Java provides control statements that help manage the flow of loops. Two commonly used control statements are break and continue.

• break Statement: The break statement is used to exit the current loop, regardless of the loop's condition. It immediately terminates the loop and transfers control to the statement following the loop. In this example, the loop will terminate when i equals 3, and the numbers 1 and 2 will be printed.

public class BreakStatementExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                break; // Exit loop when i equals 3
            }
            System.out.println(i);
        }
    }
}

• continue Statement: The continue statement skips the current iteration of the loop and moves to the next iteration. It is useful when you want to bypass certain conditions without terminating the entire loop.

public class ContinueStatementExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                continue; // Skip the iteration when i equals 3
            }
            System.out.println(i);
        }
    }
}

• In this example, when i equals 3, the continue statement will skip the printing of the number 3, resulting in the output being 1, 2, 4, and 5.

Conclusion

Nested loops and control statements are powerful tools in Java that allow you to manage complex iterations and control the flow of your programs. By understanding and using nested loops effectively, you can handle multi-dimensional data and repetitive tasks with ease. Control statements like break and continue provide additional flexibility in managing loop execution, making your code more efficient and easier to understand. Happy coding!