for vs while vs do-while: When to Use Each

Choose on the basis of what you know before the loop starts. A for loop is for the case where the number of iterations is known or bounded by a counter: the initialisation, the condition and the update all sit together in one place, so a reader sees the whole control structure at a glance. A while loop is for the case where the loop continues until some condition becomes false and you cannot predict how many times that takes — reading records until the stream is exhausted, retrying until a service responds.

A do-while differs from while in exactly one respect: the body always runs at least once, because the condition is tested after the body rather than before it. That is the right shape for input validation, where you must ask the user a question before you know whether to keep asking, and for retry loops where the first attempt is always worth making. Using a plain while loop for that case means duplicating the body or adding an artificial first-iteration flag.

Two extra loops complete the picture. The enhanced for loop, for (T item : collection), removes index bookkeeping entirely and is the clearest way to walk a collection; the trade-off is that you cannot skip ahead, and you must use the index form if you need to modify the collection while iterating. The stream forEach also covers the common case of applying an action to every element.

A practical rule: if you know the count, use for. If the condition alone decides, use while. If the body must run at least once, use do-while. If you are walking a collection, use the enhanced for.

A while loop checks its condition before running the body, so if the condition is false on the first test the body never executes at all. A do-while loop runs the body first and checks the condition afterwards, so the body always executes at least once. That is the entire difference; everything else about them is identical.

public class Main {
    public static void main(String[] args) {
        int i = 0;
        while (i < 0) {
            System.out.println("while body ran");
            i++;
        }
        System.out.println("while ran " + i + " time(s)");

        int j = 0;
        do {
            System.out.println("do-while body ran");
            j++;
        } while (j < 0);
        System.out.println("do-while ran " + j + " time(s)");

        // The enhanced for loop walks a collection without an index.
        int sum = 0;
        for (int value : new int[] {1, 2, 3, 4}) {
            sum += value;
        }
        System.out.println("sum = " + sum);
    }
}

The output makes the difference obvious: the while loop prints its body zero times because the condition is false immediately, while the do-while loop prints its body once even though the condition is also false on the first check.

Choosing between them is really a question of intent. If the body should be skipped when there is nothing to do, use while. If doing the work once is meaningful regardless of the condition, use do-while — a menu prompt, a validation retry, or a first attempt at a network call. Misusing a do-while when a while was intended is a common source of off-by-one behaviour, and it is worth saying in an interview that you would reach for do-while precisely because the at-least-once execution is a requirement rather than an accident.