while loop, which tests first and may run zero times. That guarantee is what you are actually buying, so use it when you genuinely need one guaranteed pass. Showing a menu before accepting a choice is the classic case, because the user cannot choose until they have seen the menu. Validating input once before looping is the other common one. If you do not need a guaranteed first pass, a plain while loop is the better choice, because it avoids running the body by accident when there was nothing to do. One small thing that catches everyone the first time: a do-while loop ends with a semicolon, after the closing brace. It is the only loop in Java that does, and the compiler error points confusingly close to the brace rather than the semicolon.do {
// the body runs first, always
} while (condition);
// note the semicolonCompare that with a plain while loop, which tests first.
| Question | while | do...while |
|---|---|---|
| When is the condition tested? | Before the body | After the body |
| Can the body run zero times? | Yes | No, never |
| Also called | Entry-controlled | Exit-controlled |
| Ends with | A closing brace | A brace plus a semicolon |
| Typical use | Retry, poll, read until done | Menu prompt, validate once |
Step 1 is the whole point. By the time Java evaluates the condition for the first time, your code has already had its first pass, which is exactly what makes the loop useful for input and menus.
final int LIMIT = 3;
int count = 0;
do {
System.out.println("Body ran, count is " + count);
count++;
} while (count < LIMIT);Run that and the body executes three times, ending with count at 3. The condition is tested four times in total, because the last test is the one that says stop.
Here is the clearest way to see the difference. Set the starting value so the condition is already false.
final int LIMIT = 5;
final int START_ALREADY_DONE = 10;
int count = START_ALREADY_DONE;
do {
System.out.println("this DOES print");
count++;
} while (count < LIMIT);
System.out.println("Finished, count is now " + count);The while version of this exact program prints nothing at all, because the condition is false before the first test. The do-while version prints one line and increments the counter, then discovers the condition is false and stops. That is the guarantee, demonstrated rather than asserted.
Watch out for this: because the body always runs, a do-while loop will process one item even when your collection is empty. If an empty collection should mean no work at all, use a plain while loop or a for-each loop instead.
// CORRECT
do {
count++;
} while (count < LIMIT);
// WRONG: missing semicolon
do {
count++;
} while (count < LIMIT)The second version does not compile, and the error message points at the closing brace or the start of the next line, which is nowhere near the actual problem. It frustrates almost every beginner exactly once.
The reason is grammar rather than logic. In Java, an if, a for and a while are complete once their closing brace is reached. A do-while is not, because the condition is a separate clause that follows the block, and the semicolon terminates that clause. It is the only loop in the language that needs one.
| Situation | Use | Why |
|---|---|---|
| Show a menu, then accept input | do-while | The prompt must appear at least once. |
| Ask for one value and validate it | do-while | You must ask before you can check the answer. |
| Retry an operation until it works | while | You may not want to try even once. |
| Read lines until end of file | while | An empty file should do nothing. |
| Process a collection | for-each | An empty collection means no work at all. |
| Counting | for | It keeps the count, bound and step together. |
The last three are the practical guard rails. A do-while loop is the right tool in only a narrow band of situations, and outside that band it tends to cause off-by-one style bugs because it always does one more thing than you expected.
A do-while loop guarantees one pass, not that it will ever stop. The same rule applies: something inside the body must move the condition toward false, or the loop runs forever after that first pass.
Forgetting the update here is slightly nastier than in a while loop, because the program does produce output before hanging. You get one correct-looking line and then silence, which can send you hunting in the wrong place.
| Mistake | Symptom | Fix |
|---|---|---|
| Missing semicolon after the brace | Compile error near the closing brace. | Add ; after }, unlike every other loop. |
| No update inside the body | One line of output, then the program hangs. | Add the line that moves the condition toward false. |
| Used when a zero-pass is correct | Processes one item too many. | Use a plain while loop instead. |
| Looping over an empty collection | One extra iteration on an empty list. | Use a for-each loop, which handles it correctly. |
| Update placed after a continue | Infinite loop from the second pass onward. | Put the update at the top of the body. |
| Nesting a while inside a do-while | Works, but the menu logic is hard to follow. | Extract the inner loop into its own method. |
Here is a full program showing all the important behaviours together.
final int LIMIT = 3;
final int START_ALREADY_DONE = 10;
// step one: the basic do-while
int count = 0;
do {
System.out.println("Pass " + count);
count++;
} while (count < LIMIT);
// step two: the zero-iteration proof. The body runs even
// though the condition is false from the very first test.
int alreadyDone = START_ALREADY_DONE;
do {
System.out.println("This still runs once, alreadyDone is " + alreadyDone);
alreadyDone++;
} while (alreadyDone < LIMIT);The second part is the one to internalise. If you delete the do and turn it into a plain while loop, that print statement disappears completely, because the condition is false before the first test. Same condition, same starting value, completely different behaviour.
For the wider picture across all four loops, see the looping overview page. For the two-way version of this comparison, see if...else for two-way decisions.
A loop that tests its condition after running the body, so the body always executes at least once. A do-while loop is the standard example. It is the opposite of an entry-controlled loop such as a for or while loop.
Because the condition is a separate clause that follows the block, and the semicolon terminates that clause. An if, for or while loop is complete at its closing brace, but a do-while is not, which makes it the only loop in Java that requires a trailing semicolon.
When the body must happen at least once regardless, such as displaying a menu before reading a choice or asking for one value before validating it. If the work should be skipped entirely when there is nothing to do, use a plain while loop.
Yes. The one-pass guarantee says nothing about stopping. As with any loop, something inside the body must move the condition toward false, otherwise the loop runs forever after that first pass.
The body runs once even though there is nothing to process, because the guarantee applies regardless of the data. Use a for-each loop when an empty collection should mean no iterations at all.
No, they compile to effectively the same code. Choose based on whether you genuinely need a guaranteed first pass, not on performance.
Yes. Using do { ... } while (true); is a legitimate pattern, useful for a loop that exits through break, a return or an exception rather than through its condition.
Because it is designed to. The condition is checked after the body, so the last pass is the one where the condition turns false. If you did not want that pass, you needed a while loop.
// Demonstrates the Java do-while loop.
public class DoWhileDemo {
// Stand-ins for real input so this needs no imports
// and runs in any online compiler.
static int readChoice() {
return 1;
// pretend the user typed 1
} static int readNumber() {
return 50;
// pretend the user typed 50
} public static void main(String[] args) {
final int LIMIT = 3;
final int START_ALREADY_DONE = 10;
final int MIN_VALUE = 1;
final int MAX_VALUE = 100;
final int MENU_CHOICE = 1;
final int QUIT_CHOICE = 0;
// 1) THE BASIC do-while
// The body runs first, then the condition is checked.
System.out.print("basic: ");
int count = 0;
do {
System.out.print(count + " ");
count++;
} while (count < LIMIT);
// note the semicolon
System.out.println();
// 2) THE ZERO-ITERATION PROOF
// The condition is false from the very first test, yet the
// body still runs exactly once. A plain while loop here
// would print nothing at all.
int alreadyDone = START_ALREADY_DONE;
do {
System.out.println("guaranteed pass, alreadyDone was " + alreadyDone);
alreadyDone++;
} while (alreadyDone < LIMIT);
// 3) THE SAME CODE AS A while LOOP, for contrast.
// Nothing prints, because the condition is tested first.
int whileCounter = START_ALREADY_DONE;
while (whileCounter < LIMIT) {
System.out.println("this never prints");
whileCounter++;
} System.out.println("the while version printed nothing, as expected");
// 4) INPUT VALIDATION, the classic use case.
// You must ask before you can check the answer, so the
// body has to run at least once.
int entered;
do {
System.out.println("enter a number between " + MIN_VALUE + " and " + MAX_VALUE);
entered = readNumber();
if (entered < MIN_VALUE || entered > MAX_VALUE) {
System.out.println("out of range, try again");
}
} while (entered < MIN_VALUE || entered > MAX_VALUE);
System.out.println("accepted " + entered);
// 5) A MENU REDRAWS UNTIL THE CHOICE IS VALID.
// The prompt has to appear before the user can answer.
int choice = 0;
do {
System.out.println("1. Create a report");
System.out.println("0. Quit");
choice = readChoice();
if (choice != MENU_CHOICE && choice != QUIT_CHOICE) {
System.out.println("not a valid option, try again");
}
} while (choice != MENU_CHOICE && choice != QUIT_CHOICE);
System.out.println("menu choice was " + choice);
// 6) THE INFINITE FORM, escaped by break rather than by
// the condition. Note the semicolon after while (true).
final int EXIT_AFTER = 2;
int rounds = 0;
do {
rounds++;
if (rounds >= EXIT_AFTER) {
break;
}
} while (true);
System.out.println("infinite form exited after " + rounds + " rounds");
}
}/*
ACTUAL OUTPUT:
basic: 0 1 2
guaranteed pass, alreadyDone was 10
the while version printed nothing, as expected
enter a number between 1 and 100
accepted 50
1. Create a report
0. Quit
menu choice was 1
infinite form exited after 2 rounds
THE FOUR THINGS TO REMEMBER
1) The body ALWAYS runs at least once, because the condition is
checked at the bottom rather than the top.
2) That makes it exit-controlled, the opposite of a while loop,
which may run zero times.
3) It ends with a semicolon after the closing brace, the only
loop in Java that does.
4) One guaranteed pass is not the same as terminating. The body
must still move the condition toward false or the loop hangs
after that first pass.
*/