The while loop is a fundamental control flow structure in Java, ideal for situations where we want to repeatedly execute a block of code while a specified condition is true. It offers a flexible way to handle iterative tasks without requiring the number of iterations to be known in advance.

Syntax of While Loop

The basic structure of the while loop is as follows:

while (condition) {
    // Code to be executed
}

• condition: A boolean expression that determines whether the loop will continue. If the condition is true, the loop executes. If false, the loop terminates.

Example of a While Loop

Here’s a simple example where we print numbers from 1 to 5:

int i = 1;
while (i <= 5) {
    System.out.println(i);
    i++;
}

In this example, the condition is evaluated before each iteration. As long as i is less than or equal to 5, the loop prints i and increments it.

Use Cases for While Loop

The while loop is particularly useful when the number of iterations isn’t known upfront. Some common scenarios include:

1. Reading Input: Continuously read input from a user or file until a specific value is encountered.
2. Waiting for a Condition: Monitor an event, such as waiting for a button click or a file to be written.

The Infinite While Loop

A while loop can become an infinite loop if the condition never becomes false. For example:

while (true) {
    // Infinite loop
}

An infinite loop can be useful for programs like servers, which are designed to run indefinitely until explicitly terminated.

Example: Summing Numbers with While Loop

Let’s take a slightly more complex example where we sum all integers from 1 to 100 using a while loop:

int sum = 0;
int i = 1;
while (i <= 100) {
    sum += i;
    i++;
}
System.out.println("Sum: " + sum);

This loop adds each integer to sum until i exceeds 100. After the loop finishes, we print the total sum.

The Do-While Loop: A Variant

The do-while loop is a variant of the while loop, where the code block is guaranteed to execute at least once, even if the condition is initially false. Its syntax looks like this:

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

The do-while loop is useful when we want the code to execute at least once, such as when prompting the user for input.

Example of Do-While Loop

Here’s an example using a do-while loop to prompt for input until the correct value is entered:

Scanner scanner = new Scanner(System.in);
int number;
do {
    System.out.println("Enter a number between 1 and 10:");
    number = scanner.nextInt();
} while (number < 1 || number > 10);

In this case, the loop will continue to prompt the user until they enter a valid number between 1 and 10.

When to Use While vs. Do-While Loop

• While Loop: When the condition must be checked before executing the loop body.
• Do-While Loop: When the loop body should execute at least once, even if the condition is false on the first check.

Conclusion

The while and do-while loops are essential for controlling the flow of Java programs, allowing us to repeat tasks as long as certain conditions are met. Understanding their differences and use cases will help in writing efficient code. For more information, check the official Java documentation on while loops.