{"title":"Do-While Loop","description":"","content":"A `do-while` loop runs its body first, then checks the condition. That tiny reordering matters a lot in practice. When a block of code must always execute at least once before deciding whether to repeat, `do-while` is the right loop.\n\n---\n\n# The Basic Shape\n\nA `do-while` loop has three parts: the `do` keyword, a body block in braces, and a `while (condition);` at the bottom. That trailing semicolon is part of the syntax, not optional.\n\n\n```java\npublic class FirstDoWhile {\n public static void main(String[] args) {\n int itemNumber = 1;\n do {\n System.out.println(\"Showing product \" + itemNumber);\n itemNumber++;\n } while (itemNumber <= 3);\n }\n}\n```\n\n\nThe flow goes: enter the body, run it, evaluate the condition, loop back to the body if it's true, exit if it's false. The condition lives at the bottom, so the body has already executed once before the loop even thinks about whether to continue.\n\n---\n\n# How Execution Flows\n\nThe control flow is short to describe but useful to picture. A `do-while` body always runs, then the condition decides whether to run it again.\n\n\n```mermaid\nflowchart TD\n START([Start]):::startNode --> BODY[Run loop body]:::primary\n BODY --> CHECK{Condition
true?}:::decision\n CHECK -->|Yes| BODY\n CHECK -->|No| EXIT([Exit loop]):::exit\n\n classDef startNode fill:#38d9a9,stroke:#000,color:#000\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef decision fill:#ffa94d,stroke:#000,color:#000\n classDef exit fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThere is no arrow that lets the program skip the body. Even if the condition would have been false from the start, the body still runs once. That's the reason `do-while` exists.\n\n---\n\n# Contrast With While\n\nA regular `while` loop checks the condition first. If it's already false, the body never runs at all. A `do-while` runs the body, then checks. Same code, different starting condition, different output.\n\nHere's the same logic written both ways. The starting balance is already below the threshold:\n\n\n```java\npublic class WhileVsDoWhile {\n public static void main(String[] args) {\n int cartItemsWhile = 0;\n while (cartItemsWhile > 0) {\n System.out.println(\"while: cart has \" + cartItemsWhile + \" items\");\n cartItemsWhile--;\n }\n System.out.println(\"while loop done\");\n\n int cartItemsDoWhile = 0;\n do {\n System.out.println(\"do-while: cart has \" + cartItemsDoWhile + \" items\");\n cartItemsDoWhile--;\n } while (cartItemsDoWhile > 0);\n System.out.println(\"do-while loop done\");\n }\n}\n```\n\n\nThe `while` loop printed nothing from its body because the condition was already false on entry. The `do-while` printed once, then checked the condition, found it false, and stopped. That single guaranteed pass is the defining feature.\n\n---\n\n# The Mandatory Trailing Semicolon\n\nThe semicolon after `while (...)` is required. Without it, the compiler refuses to build. This is the most common mistake learners make with `do-while`.\n\n**What's wrong with this code?**\n\n\n```java\npublic class MissingSemicolon {\n public static void main(String[] args) {\n int productId = 1;\n do {\n System.out.println(\"Product \" + productId);\n productId++;\n } while (productId <= 3)\n }\n}\n```\n\n\nThis won't compile. The compiler produces an error like:\n\n\n```shell\nerror: ';' expected\n } while (productId <= 3)\n ^\n```\n\n\nThe fix is one character. Put the semicolon back at the end of the `while (...)` line:\n\n**Fix:**\n\n\n```java\npublic class WithSemicolon {\n public static void main(String[] args) {\n int productId = 1;\n do {\n System.out.println(\"Product \" + productId);\n productId++;\n } while (productId <= 3);\n }\n}\n```\n\n\nWhy does Java demand it? The `do-while` statement is a single statement and Java statements terminate with a semicolon. The `while` part of a normal `while` loop doesn't need one because it's followed directly by the body block, but here the body comes first and the condition closes the whole statement.\n\n---\n\n# Input Validation\n\nThe best use case for `do-while` is reading input and checking if it's valid. Reading has to happen first, otherwise there's nothing to check. That fits `do-while` perfectly: act first, then validate.\n\nTo keep the output predictable, this example simulates input with a small array instead of reading from the keyboard. The logic is the same. Each attempt is an entry from `attemptedIds`. The loop keeps going until it sees a valid product ID.\n\n\n```java\npublic class ProductIdValidation {\n public static void main(String[] args) {\n int[] attemptedIds = {-5, 0, 17, 23};\n int attemptIndex = 0;\n int productId;\n\n do {\n productId = attemptedIds[attemptIndex];\n System.out.println(\"Attempt \" + (attemptIndex + 1) + \": entered \" + productId);\n attemptIndex++;\n } while (productId <= 0);\n\n System.out.println(\"Accepted product ID: \" + productId);\n }\n}\n```\n\n\nThe body runs, reads an attempt, then the condition decides whether the value was good. Bad input loops back. Good input falls out the bottom. Writing this with a regular `while` is awkward because it would require either priming the variable with a dummy value or copying the read step both before and inside the loop.\n\nHere's the same idea with `Scanner` when actual keyboard input is needed. The expected output below assumes the user typed `-2`, then `0`, then `42`:\n\n\n```java\nimport java.util.Scanner;\n\npublic class ScannerProductId {\n public static void main(String[] args) {\n Scanner input = new Scanner(System.in);\n int productId;\n do {\n System.out.print(\"Enter a product ID: \");\n productId = input.nextInt();\n } while (productId <= 0);\n System.out.println(\"Accepted product ID: \" + productId);\n }\n}\n```\n\n\n---\n\n# Retry Until Success\n\nThe same pattern fits retries. Try something, check the result, try again if it failed. The action happens at least once, so `do-while` is the right shape. This example simulates checkout attempts where the first two fail and the third succeeds.\n\n\n```java\npublic class CheckoutRetry {\n public static void main(String[] args) {\n boolean[] attemptResults = {false, false, true};\n int attempt = 0;\n boolean paymentConfirmed;\n\n do {\n paymentConfirmed = attemptResults[attempt];\n System.out.println(\"Attempt \" + (attempt + 1)\n + \": payment confirmed = \" + paymentConfirmed);\n attempt++;\n } while (!paymentConfirmed && attempt < attemptResults.length);\n\n if (paymentConfirmed) {\n System.out.println(\"Checkout complete after \" + attempt + \" attempts.\");\n } else {\n System.out.println(\"Checkout failed after \" + attempt + \" attempts.\");\n }\n }\n}\n```\n\n\nThe condition has two parts joined with `&&`: keep going if payment isn't confirmed AND attempts remain. The second part prevents the loop from running forever when every attempt fails.\n\n---\n\n# Menu Loops\n\nMenu loops are another natural fit. Show the menu, take a choice, act on it, then loop unless the choice was \"exit\". Like input validation, the menu has to appear once before the decision to show it again can be made.\n\n\n```java\npublic class OrderStatusMenu {\n public static void main(String[] args) {\n String[] choices = {\"track\", \"cancel\", \"track\", \"exit\"};\n int step = 0;\n String choice;\n\n do {\n System.out.println(\"--- Order Status Menu ---\");\n System.out.println(\"1) track\");\n System.out.println(\"2) cancel\");\n System.out.println(\"3) exit\");\n choice = choices[step];\n System.out.println(\"You chose: \" + choice);\n\n if (choice.equals(\"track\")) {\n System.out.println(\"Order #1042 is out for delivery.\");\n } else if (choice.equals(\"cancel\")) {\n System.out.println(\"Order #1042 cancelled.\");\n }\n\n step++;\n } while (!choice.equals(\"exit\"));\n\n System.out.println(\"Goodbye.\");\n }\n}\n```\n\n\nThe menu always appears once, the user always picks once, and the loop only exits when the chosen action is `exit`. A regular `while` would require printing the menu before the loop and again at the bottom of the body, which duplicates code.\n\n---\n\n# The \"Already Valid\" Trap\n\nThe same property that makes `do-while` good for validation can backfire. If the input is already correct, the body still runs once. That's only a problem when the body does something that shouldn't repeat unconditionally, like printing a prompt or charging a card.\n\n**What's wrong with this code?**\n\n\n```java\npublic class AlreadyValidTrap {\n public static void main(String[] args) {\n int quantity = 2;\n do {\n System.out.println(\"Please enter a positive quantity.\");\n // pretend we read user input here\n quantity = 5;\n } while (quantity <= 0);\n System.out.println(\"Final quantity: \" + quantity);\n }\n}\n```\n\n\nThe original `quantity` was already `2`, which is positive. The user should never have seen the \"Please enter\" prompt. The body ran once because that's what `do-while` does. The fix is to check first when the value might already be valid:\n\n**Fix:**\n\n\n```java\npublic class CheckFirst {\n public static void main(String[] args) {\n int quantity = 2;\n while (quantity <= 0) {\n System.out.println(\"Please enter a positive quantity.\");\n quantity = 5;\n }\n System.out.println(\"Final quantity: \" + quantity);\n }\n}\n```\n\n\nRule of thumb: use `do-while` when the body has to run at least once to produce the value being checked. Use `while` when the value already exists and the action should only happen if a condition is true.","pageType":"java"}

Do-While Loop

Get Premium