Chapter 11 — Java Loop Control

The Power of Repetition

Loops are a fundamental concept in programming that allow you to execute a block of code repeatedly as long as a certain condition is met. They are the backbone of automation, enabling you to handle tasks like processing a list of items, counting, or waiting for a specific event without writing redundant code.

In Java, there are several types of loops, each with its own strengths and ideal use cases. In this chapter, we will explore the most common ones, starting with the basic while and for loops, and then moving to the more specialized do-while and the enhanced for-each loop. We will also cover crucial loop control statements like break and continue that give you fine-grained control over how your loops execute.

Why Loops Are Essential

• Efficiency: Loops allow you to write a short, reusable block of code instead of copying and pasting the same logic hundreds of times.
• Automation: They are the core of algorithms that process data, from simple calculators to complex data analysis.
• Readability: Well-structured loops make your program's logic easier to understand for you and other developers.

Mastering loops is a critical step from writing simple scripts to becoming a proficient programmer. Let's dive in.

Repeating While a Condition is True

The while loop is the most basic iterative control structure in Java. Its beauty lies in its simplicity: it continues to execute a block of code as long as a specified boolean condition evaluates to true. The condition is checked *before* the loop body is executed in each iteration. This makes it the perfect choice when you don't know in advance how many times you need to repeat an action.

Syntax

while (condition) {
    // code block to be executed repeatedly
}

Flowchart

   +-------------+
   |  Start Loop |
   +------ + ----+
          |
          v
   +-------------+
   | Check Cond? |----> FALSE ----> Exit Loop
   +------ + ----+
          |
        TRUE
          |
          v
   +-------------+
   | Execute Code|
   +------ + ----+
          |
      Repeat Loop

Example: Counting to 10

This example demonstrates a simple counter. We initialize an integer i to 1. The while loop checks if i is less than or equal to 10. Inside the loop, we print the current value of i and then increment it. This process repeats until i becomes 11, at which point the condition (i <= 10) becomes false, and the loop terminates.

public class WhileLoopExample {
    public static void main(String[] args) {
        int count = 1; // Initialize the counter variable
         
        // The loop's condition: continue as long as 'count' is 10 or less
        while (count <= 10) {
            // This is the body of the loop. It runs on each iteration.
            System.out.println("Count is: " + count);
            
            count++; // Increment the counter. This is crucial! Without it, we'd have an infinite loop.
        }
         
        // This line executes after the loop condition is false.
        System.out.println("Loop finished!");
    }
}

Common Pitfall: The Infinite Loop

Warning: The most common mistake with while loops is creating a condition that never becomes false. For example, while (true). This results in an infinite loop, a loop that never ends and will cause your program to hang. Always ensure there is a clear and achievable way for your loop to terminate.

Best Practices

• Clear Initialization: Always initialize your loop counter variable before the loop starts.
• Clear Update: Ensure the loop's control variable is updated inside the loop to make progress towards the end condition.
• Termination Condition: The condition should be based on the loop counter, not a magic number, to make the loop's purpose clear.

Repeating for a Known Number of Times

The for loop is ideal when you know exactly how many times you want to execute a block of code. It's more concise than a while loop for this scenario because it combines the initialization, condition, and iteration steps into a single, elegant line.

Syntax

for (initialization; condition; update) {
    // code block to be executed repeatedly
}

Let's break down the three parts:

• Initialization: An expression that runs once at the very beginning of the loop. It's typically used to declare and initialize a counter variable (e.g., int i = 1;).
• Condition: A boolean expression that is evaluated *before* each iteration. If it's true, the loop continues; if it's false, the loop terminates (e.g., i <= 10;).
• Update: An expression that runs at the *end* of each iteration. It's usually used to increment or decrement the counter variable (e.g., i++).

Example: Counting to 10 (The For Loop Way)

This example achieves the same result as the while loop example but is often considered cleaner and less error-prone for a fixed number of iterations. The entire loop's lifecycle is managed within the parentheses, making it easy to see at a glance.

public class ForLoopExample {
    public static void main(String[] args) {
        // Initialization: int i = 1;
        // Condition: i <= 10;
        // Update: i++
        for (int i = 1; i <= 10; i++) {
            System.out.println("Count is: " + i);
        }
         
        System.out.println("Loop finished!");
    }
}

Best Practices

• Use for Fixed Iterations: The for loop is the standard choice when the number of iterations is known beforehand.
• Descriptive Variable Names: Use a clear counter name like i, count, or itemIndex instead of a single letter.
• Avoid Off-By-One Errors: Be careful with the condition (e.g., using < instead of <=) to prevent the loop from running one time too many.

Execute at Least Once

The do-while loop is a close relative of the while loop. It has one key difference: the loop's code block is always executed at least once before the condition is checked for the first time.

This makes it particularly useful for situations where you need to perform an action at least once, such as displaying a menu to a user and processing their choice. You can guarantee the menu appears before the user makes a choice.

Syntax

do {
    // code block to be executed
} while (condition);

Notice the while statement and its condition now appear *after* the code block. The flow is: "do this, then check if you should do it again."

Example: A Simple Menu

This program displays a menu to the user at least once. It will continue to prompt the user for a choice until they choose to exit (option 2). This demonstrates the "execute at least once" nature of the do-while loop.

import java.util.Scanner; // Import the Scanner class for user input

public class DoWhileExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // Create a Scanner object
        int choice;
         
        // The 'do-while' loop begins
        do {
            // Display the menu options
            System.out.println("Menu:");
            System.out.println("1. Perform Action A");
            System.out.println("2. Exit");
            System.out.print("Enter your choice: ");
            
            choice = scanner.nextInt(); // Read user's input
        } while (choice != 2); // Loop continues as long as choice is not 2
         
        // This line is reached only after the loop terminates
        System.out.println("You chose to exit.");
        scanner.close(); // Good practice: close the scanner
    }
}

Best Practices

• Guaranteed Execution: Use a do-while loop for input validation where the input prompt must be shown at least once.
• Clear Exit Condition: The exit condition should be simple and unambiguous to the user (e.g., "Enter 2 to exit").

Altering the Normal Flow

Sometimes, you don't want to execute a loop in its entirety. You might need to exit early when you find what you're looking for, or you might want to skip an item under a certain condition. Java provides powerful loop control statements—break and continue—to give you this fine-grained control.

Exiting a Loop Immediately

The break statement is a powerful command that can be used inside a loop (or a switch statement) to immediately terminate the loop and transfer control to the statement that comes immediately after the loop. It's like an emergency exit for your loop.

It's most commonly used to exit a loop early when a specific condition is met, such as finding a target number in a list or array. Once found, there's no need to continue searching.

Example: Finding a Number in an Array

Here, we search an array of integers for the number 42. The for loop iterates through each element. The if statement checks if the current element matches our target. If it does, we print a success message and use the break statement to exit the loop immediately, saving unnecessary iterations.

public class BreakExample {
    public static void main(String[] args) {
        int[] numbers = {10, 25, 5, 42, 17};
        int target = 42;
        boolean found = false;
         
        // Loop through the array to find the target
        for (int number : numbers) {
            if (number == target) {
                System.out.println("Found the number " + target + "!");
                found = true;
                break; // Exit the loop immediately
            }
        }
         
        // This message is only printed if the loop completes without finding the number
        if (!found) {
            System.out.println("Number " + target + " was not in the list.");
        }
    }
}

Best Practices

• Use for Efficiency: Don't use break as a substitute for a proper loop condition. It should be used to exit early, not to control the main flow.
• Avoid in Deep Nesting: Overusing break in deeply nested loops can make code hard to read and debug. Try to structure your logic to minimize deep breaks when possible.

Skipping an Iteration

The continue statement works as the opposite of break. Instead of terminating the loop, it tells the loop to immediately stop the current iteration and jump to the next one. It's like saying, "skip this one, but keep going with the rest."

This is useful when you want to ignore a specific value within a loop but still want to complete the loop. For example, printing only the odd numbers from 1 to 10.

Example: Printing Only Odd Numbers

The for loop iterates from 1 to 10. Inside, an if statement checks if the number i is even. If it is, the continue statement is executed, which immediately jumps to the next iteration of the loop, skipping the System.out.println() for that even number.

public class ContinueExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            // If the number is even, skip the rest of the loop body
            if (i % 2 == 0) {
                continue; // Go to the next iteration
            }
            System.out.println(i); // This line is only reached for odd numbers
        }
    }
}

Best Practices

• Improve Readability: The continue statement can make a loop's logic clearer by handling edge cases at the beginning of an iteration, rather than nesting a complex if-else block.
• Avoid Side-Effects: Be aware that continue skips the *rest of the loop body*, including any update statements. If your loop relies on an update, continue might cause bugs.

Simplifying Iteration over Collections

Introduced in Java 5, the enhanced for loop (also known as the "for-each" loop) provides a much simpler and cleaner way to iterate over all elements in a collection, such as an array or a list. It eliminates the need for a separate counter variable and manual index management, reducing the chance of errors.

Syntax

for (dataType item : collection) {
    // code block to be executed for each item
}

The syntax reads like: "for each element of this type, in this collection." Java handles all the complexity of the iteration behind the scenes.

Example: Iterating an Array of Strings

This example shows how cleanly you can process a list of items. The loop automatically assigns each element of the fruits array to the fruit variable in each iteration. There is no need to manage an index i or call fruits[i].

public class EnhancedForExample {
    public static void main(String[] args) {
        String[] fruits = {"Apple", "Banana", "Orange", "Mango"};
         
        // 'fruit' is a variable that holds one element from the array in each iteration
        for (String fruit : fruits) {
            System.out.println("I like " + fruit);
        }
    }
}

Why It's Better

• Readability: The intent of the loop is immediately clear: "for each fruit in the list." It's less cluttered than a traditional for loop with an index.
• Safety: It prevents common "off-by-one" or "index out of bounds" errors that can occur with manual index management.
• Flexibility: The code works with any collection that implements the Iterable interface, not just arrays.

Test Your Loop Skills

The best way to master loops is to solve problems. Try these questions to apply the concepts from this chapter. Each problem is designed to make you think about the loop's initialization, condition, and update.

1. Print numbers from 100 down to 1. Use a for loop that counts down.
2. Print multiplication table of any number. Use nested loops: an outer loop for the multiplicand and an inner loop for the multiplier.
3. Count digits in a number. Use a while loop and the modulo operator (%) to extract and sum the digits.
4. Reverse a number. Use a loop to reverse the digits of a number entered by the user.
5. Find the average of an array of numbers. Use an enhanced for-each loop to sum the numbers, then divide by the count for the average.
6. Print a pattern: Use nested loops to create patterns like a pyramid or a right-angled triangle.