Java Loop Control

Java - Loop Control

Loops are fundamental control structures in programming that allow you to execute a block of code repeatedly as long as a certain condition remains true, or for a specific number of iterations.

Java provides several looping mechanisms:

• while Loop: Executes a block of code as long as a condition is true (checked before each iteration).
• do...while Loop: Similar to while, but the condition is checked after the block executes, guaranteeing at least one execution.
• for Loop: Typically used when the number of iterations is known beforehand. Initializes a counter, checks a condition, and updates the counter in each iteration.
• Enhanced for Loop (or for-each loop): Provides a concise way to iterate over elements in an array or collection.

The while Loop

The while loop repeatedly executes a target statement as long as a given boolean condition is true. The condition is checked before the loop body executes.

Syntax:

while (boolean_expression) {
    // Statements to execute repeatedly
    // Usually includes logic to eventually make the expression false
}

Flow: The boolean_expression is evaluated. If true, the statements inside the loop body are executed. Then, the expression is evaluated again. This repeats until the expression becomes false. If the expression is initially false, the loop body never executes.

Example:

public class WhileLoopExample {
    public static void main(String[] args) {
        int count = 0; // Initialization

        while (count < 5) { // Condition check
            System.out.println("Current count: " + count);
            count++; // Update (crucial to avoid infinite loop!)
        }
        System.out.println("Loop finished.");
    }
}

Output:

Current count: 0
Current count: 1
Current count: 2
Current count: 3
Current count: 4
Loop finished.

The do...while Loop

The do...while loop is similar to the while loop, but the condition is tested after the loop body executes. This guarantees that the loop body runs at least once, even if the condition is initially false.

Syntax:

do {
    // Statements to execute
    // Update logic often goes here
} while (boolean_expression);

Flow: The statements inside the loop body are executed first. Then, the boolean_expression is evaluated. If true, the loop repeats. If false, the loop terminates.

Example:

import java.util.Scanner;

public class DoWhileExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int number;

        do {
            System.out.print("Enter a positive number (or 0 to exit): ");
            number = scanner.nextInt();
            if (number > 0) {
                System.out.println("You entered: " + number);
            }
        } while (number > 0); // Condition checked after execution

        System.out.println("Exiting program.");
        scanner.close();
    }
}

Sample Interaction:

Enter a positive number (or 0 to exit): 10
You entered: 10
Enter a positive number (or 0 to exit): 5
You entered: 5
Enter a positive number (or 0 to exit): 0
Exiting program.

The for Loop

The for loop provides a concise way to iterate a specific number of times. It combines initialization, condition checking, and updating of a loop control variable into one line.

Syntax:

for (initialization; boolean_expression; update) {
    // Statements to execute
}

Flow of Control:

1. Initialization: Executed once at the very beginning. Usually declares and initializes a loop counter variable (e.g., int i = 0).
2. Condition Check: The boolean_expression is evaluated before each iteration (including the first). If true, the loop body executes. If false, the loop terminates.
3. Loop Body Execution: If the condition is true, the statements inside the loop execute.
4. Update: Executed after the loop body finishes each iteration. Typically increments or decrements the loop counter (e.g., i++, i--).
5. The flow then returns to step 2 (Condition Check).

Example:

public class ForLoopExample {
    public static void main(String[] args) {
        // Loop from 0 up to (but not including) 5
        for (int i = 0; i < 5; i++) {
            System.out.println("Iteration number: " + i);
        }
        System.out.println("For loop finished.");
    }
}

Output:

Iteration number: 0
Iteration number: 1
Iteration number: 2
Iteration number: 3
Iteration number: 4
For loop finished.

Enhanced for Loop (for-each)

Introduced in Java 5, the enhanced for loop simplifies iteration over arrays and collections. It eliminates the need for index management.

Syntax:

for (ElementType element : collectionOrArray) {
    // Statements using 'element'
}

• ElementType: The data type of the elements in the collection or array.
• element: A variable name declared within the loop. In each iteration, it holds the current element from the sequence.
• collectionOrArray: The array or collection object (e.g., ArrayList, HashSet) you want to iterate over.

Example:

import java.util.ArrayList;
import java.util.List;

public class EnhancedForExample {
    public static void main(String[] args) {
        // Example with an array
        int[] numbers = {10, 20, 30, 40, 50};
        System.out.println("Iterating over array:");
        for (int number : numbers) {
            System.out.print(number + " ");
        }
        System.out.println("\n");

        // Example with a List (Collection)
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        System.out.println("Iterating over List:");
        for (String name : names) {
            System.out.print(name + " ");
        }
        System.out.println();
    }
}

Output:

Iterating over array:
10 20 30 40 50

Iterating over List:
Alice Bob Charlie

Loop Control Statements: break and continue

Java provides statements to alter the normal flow of loop execution.

The break Keyword

The break keyword is used to terminate the innermost loop ( while, do-while, for) or switch statement immediately. Execution jumps to the statement following the terminated loop or switch.

Syntax:

`break;`

Example:

public class BreakExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};

        for (int number : numbers) {
            if (number == 30) {
                System.out.println("Found 30, breaking loop.");
                break; // Exit the loop immediately
            }
            System.out.println("Processing: " + number);
        }
        System.out.println("After the loop.");
    }
}

Output:

Processing: 10
Processing: 20
Found 30, breaking loop.
After the loop.

The continue Keyword

The continue keyword skips the rest of the current iteration of the innermost loop (while, do-while, for) and proceeds directly to the next iteration.

• In a for loop, continue jumps to the update statement.
• In a while or do-while loop, continue jumps to the condition check.

Syntax:

`continue;`

Example:

public class ContinueExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                System.out.println("Skipping iteration 3.");
                continue; // Skip the rest of this iteration
            }
            System.out.println("Processing iteration: " + i);
        }
        System.out.println("Loop finished.");
    }
}

Output:

Processing iteration: 1
Processing iteration: 2
Skipping iteration 3.
Processing iteration: 4
Processing iteration: 5
Loop finished.

Choosing the Right Loop

• Use for when you know (or can calculate) the number of iterations in advance.
• Use enhanced for (for-each) for simple iteration over all elements of an array or collection when you don’t need the index.
• Use while when you need to loop based on a condition, and the number of iterations isn’t known beforehand. Also suitable when the loop might not need to execute at all.
• Use do-while when you need the loop body to execute at least once before the condition is checked.

What is Next?

Having covered decision making and looping, the next chapters will explore specific data types like Numbers, Characters, and Strings in more detail, along with associated operations and methods.