while Loop

6.1.1 Basic while Loop

The while loop is one of the simplest yet most powerful tools for repetition in Java.
Unlike the for loop — which is best when you know exactly how many times to repeat — the while loop shines when the number of repetitions is unknown at the start.

The basic idea is simple: while the condition is true, keep executing the code block.
Each time the loop body runs, the condition is checked again.
If the condition is false when the loop first starts, the body won’t run at all.

This makes while perfect for open-ended tasks like waiting for a user to provide valid input, listening for a message from a server, or checking a flag that changes during runtime.

However, the same flexibility makes it easy to create a logic bug: if nothing inside the loop changes the condition, the loop will run forever.
So it’s critical to always plan what will eventually stop the loop.
Good while loops are clear about:

• When the loop starts,

• When the loop should end,

• How the loop’s condition changes over time.

In web apps and backend servers, while loops often handle real-time operations like listening for incoming data, checking if a connection is still alive, or polling a database until new results arrive.

Mastering this simple pattern means you can build both short user input checks and large-scale services that run continuously.

Mini Lab

java
public class BasicWhile {
    public static void main(String[] args) {
        int count = 1;

        while (count <= 5) {
            System.out.println("Count: " + count);
            count++;
        }
    }
}

6.1.2 Validating Input with while

One of the most practical uses for the while loop is input validation.
Imagine you’re asking a user for a positive number — you can’t trust they’ll always type something valid on the first try!

A while loop lets you keep asking again and again until the input is acceptable.
Each loop checks the condition: is the number positive? If yes, you’re done. If not, you repeat.

This is far more user-friendly than just rejecting bad input once and crashing the program.
Instead, you keep the user engaged in the loop until they get it right.

In web and desktop apps, this logic appears anywhere you gather input:

• Ensuring an email field isn’t empty,

• Making sure a password meets length requirements,

• Forcing the user to agree to terms before submitting a form.

Using while for validation also keeps your main logic clean — instead of scattered error checks, you wrap the risky input in a loop that only lets correct data through.

Mini Lab

java
import java.util.Scanner;

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

        while (number <= 0) {
            System.out.print("Enter a positive number: ");
            number = scanner.nextInt();
        }

        System.out.println("You entered: " + number);
        scanner.close();
    }
}

6.1.3 Infinite Loops and Control

A while loop can also run forever — but only if you want it to!
This is called an infinite loop, and it’s surprisingly common in real-world applications.

For example, think of a server that must always be ready to handle incoming requests.
It can’t “end” after a fixed number of checks — it has to keep looping, listening for events until an admin stops it or the server shuts down.

This pattern looks like:

java
while (true) {
    // Keep running forever
}

Of course, you don’t want your loop to lock up your program.
So infinite loops should always include break, return, or external exit conditions that allow them to finish gracefully.

Good examples:

• A game loop that runs until the user clicks "Quit".

• A chatbot loop that listens for input until the user says "bye".

• A background task that repeats until it gets a shutdown signal.

The key is control.
An infinite loop without control is a bug.
An infinite loop with clear break points is a robust engine.

Always plan:

• What keeps the loop alive,

• What stops it,

• How you handle emergency exits.

Mini Lab

java
public class InfiniteWhile {
    public static void main(String[] args) {
        int i = 0;

        while (true) {
            System.out.println("Running... i = " + i);
            i++;
            if (i >= 5) {
                System.out.println("Breaking out of infinite loop.");
                break;
            }
        }
    }
}