{"title":"While Loop","description":"","content":"A `while` loop runs a block of code over and over as long as a condition stays true. It fits cases where the number of iterations isn't known up front, like draining a queue of pending orders or asking the customer for input until they type something valid. This lesson covers the syntax, when `while` is a better fit than `for`, and common bugs.\n\n---\n\n# Syntax and Semantics\n\nThe shape of a `while` loop is simple:\n\n\n```shell\nwhile (condition) {\n // body runs while condition is true\n}\n```\n\n\nJava evaluates the condition first. If it's `true`, the body runs once, and then the condition is checked again. If the condition is `false` the very first time, the body runs **zero times** and execution moves on. This is why `while` is called a pre-test loop: the test happens before the body, every time.\n\nHere's a tiny example that prints the remaining stock as items get sold:\n\n\n```java\npublic class StockCountdown {\n public static void main(String[] args) {\n int remainingStock = 5;\n while (remainingStock > 0) {\n System.out.println(\"Stock left: \" + remainingStock);\n remainingStock--;\n }\n System.out.println(\"Out of stock\");\n }\n}\n```\n\n\nThe condition `remainingStock > 0` is checked, the body runs and decrements `remainingStock`, and the cycle repeats. When `remainingStock` hits `0`, the condition is `false` and Java falls through to the line after the loop.\n\nThis diagram traces the control flow:\n\n\n```mermaid\nflowchart TD\n A[Start]:::cyan --> B{Condition
true?}:::orange\n B -- Yes --> C[Run loop body]:::teal\n C --> D[Update state]:::green\n D --> B\n B -- No --> E[Exit loop]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe arrow from \"Update state\" back to the condition is the key part. If the body never changes anything the condition looks at, the loop runs forever.\n\n---\n\n# When to Choose `while` Over `for`\n\nThe `for` loop works best when the iteration count is known in advance, like \"run 10 times\" or \"walk through every index of an array.\" The `while` loop is the better choice when the number of iterations depends on something that can change at runtime.\n\nThree common cases:\n\n1. **Unknown iteration count.** Items are processed from a queue and the queue's size changes as work proceeds.\n2. **Sentinel-driven loop.** Input is read until a specific terminator value appears.\n3. **Waiting for a condition to change.** State is checked and an action runs when it flips.\n\nHere's an example of case 1. The shop has a list of pending orders and the loop keeps processing them until none are left. The exact count isn't known until the loop runs:\n\n\n```java\npublic class OrderProcessor {\n public static void main(String[] args) {\n int pendingOrders = 7;\n int processed = 0;\n while (pendingOrders > 0) {\n processed++;\n pendingOrders--;\n System.out.println(\"Processed order #\" + processed);\n }\n System.out.println(\"All orders done. Total: \" + processed);\n }\n}\n```\n\n\nA `for` loop would also work, but the `while` reads more naturally: keep going while there's work to do. A `for` loop frames the problem as \"from index 0 to n\", which doesn't match the shape of this task.\n\nA running total over a varying number of cart items is another fit. The cart can have any number of products, and the loop stops when the cart is empty:\n\n\n```java\npublic class RunningTotal {\n public static void main(String[] args) {\n double[] cartPrices = {19.99, 5.49, 12.00, 8.75};\n double total = 0.0;\n int index = 0;\n while (index < cartPrices.length) {\n total += cartPrices[index];\n index++;\n }\n System.out.println(\"Cart total: $\" + total);\n }\n}\n```\n\n\nFor a fixed array, a `for` loop is arguably cleaner here. The pattern is most useful when the source has no known length: a stream of inputs, a queue being popped, a customer who keeps adding items.\n\n---\n\n# Sentinel-Controlled Loops\n\nA sentinel value is a special marker that tells the loop to stop. The classic use is reading input until the user types a terminator. The loop doesn't know how many lines the user will enter; it keeps reading until it sees the signal.\n\nThis program asks the customer for product prices and keeps a running total. Entering `0` ends the input:\n\n\n```java\nimport java.util.Scanner;\n\npublic class CartBuilder {\n public static void main(String[] args) {\n Scanner scanner = new Scanner(System.in);\n double total = 0.0;\n System.out.println(\"Enter product prices (0 to finish):\");\n double price = scanner.nextDouble();\n while (price != 0) {\n total += price;\n price = scanner.nextDouble();\n }\n System.out.println(\"Cart total: $\" + total);\n }\n}\n```\n\n\n**Sample interaction:**\n\n\n```shell\nEnter product prices (0 to finish):\n19.99\n5.49\n12.00\n0\nCart total: $37.48\n```\n\n\nFirst, the loop reads one value **before** the loop starts, so the condition has something to check. This is called priming the loop. Second, the last statement inside the body reads the next value, which becomes the new condition input. Without that second read, the loop would test the same value forever.\n\nAnother sentinel pattern shows up when a program prompts the user repeatedly until a valid input arrives:\n\n\n```java\nimport java.util.Scanner;\n\npublic class QuantityPrompt {\n public static void main(String[] args) {\n Scanner scanner = new Scanner(System.in);\n int quantity = -1;\n while (quantity < 1) {\n System.out.print(\"Enter quantity (1 or more): \");\n quantity = scanner.nextInt();\n }\n System.out.println(\"Adding \" + quantity + \" items to cart\");\n }\n}\n```\n\n\n**Sample interaction:**\n\n\n```shell\nEnter quantity (1 or more): -3\nEnter quantity (1 or more): 0\nEnter quantity (1 or more): 2\nAdding 2 items to cart\n```\n\n\nThe initial value `-1` is deliberately invalid so the loop enters at least once. Each pass re-prompts. As soon as the user types something valid, the condition fails and the loop exits.\n\n---\n\n# Restocking Until a Threshold\n\nThe \"wait for a condition to change\" pattern often looks like topping something up until it crosses a line. Consider a warehouse that restocks a product until it has at least 20 units on hand. Each restock adds a fixed amount:\n\n\n```java\npublic class RestockLoop {\n public static void main(String[] args) {\n int currentStock = 3;\n int restockSize = 8;\n int minThreshold = 20;\n int restockEvents = 0;\n while (currentStock < minThreshold) {\n currentStock += restockSize;\n restockEvents++;\n System.out.println(\"Restock #\" + restockEvents + \": stock now \" + currentStock);\n }\n System.out.println(\"Done. Stock at \" + currentStock + \" after \" + restockEvents + \" restocks\");\n }\n}\n```\n\n\nThe number of restocks isn't known in advance. It depends on the starting stock and the restock size. The loop figures it out by checking the condition each pass.\n\n---\n\n# Infinite Loops and When They're Legitimate\n\nAn infinite loop is one whose condition never becomes `false`. The simplest form is `while (true)`, where the condition is a literal `true`:\n\n\n```shell\nwhile (true) {\n // runs forever, unless something inside stops it\n}\n```\n\n\nThat sounds like a bug, and most of the time it is. But there are real cases where an infinite loop is the right shape:\n\n- A long-running process that handles work as it arrives, like a server waiting for incoming orders.\n- A retry pattern where you keep trying an action until it succeeds.\n- A menu-driven program that keeps showing options until the user picks \"quit.\"\n\nIn every legitimate use, something inside the body breaks out of the loop. The exit happens with a `break` statement, a `return` from the surrounding method, or an exception. The shape, kept abstract:\n\n\n```java\npublic class OrderQueueWorker {\n public static void main(String[] args) {\n int orderCount = 0;\n while (true) {\n orderCount++;\n System.out.println(\"Handling order \" + orderCount);\n if (orderCount >= 3) {\n System.out.println(\"Shutting down\");\n break;\n }\n }\n }\n}\n```\n\n\nThe `break` statement here jumps out of the nearest enclosing loop. For now, the takeaway is that `while (true)` is fine when the body has a clear exit path. Without one, the result is an unintentional infinite loop, and that's a different story.\n\n---\n\n# Common Bugs\n\nThe two most common `while` loop mistakes both come from sloppy bookkeeping around the condition variable. Both are easy to spot with practice.\n\n### Forgetting to Update the Condition Variable\n\n**What's wrong with this code?**\n\n\n```java\npublic class StockBug {\n public static void main(String[] args) {\n int remainingStock = 3;\n while (remainingStock > 0) {\n System.out.println(\"Selling unit. Stock: \" + remainingStock);\n }\n System.out.println(\"Sold out\");\n }\n}\n```\n\n\nThe condition checks `remainingStock`, but the body never changes it. `remainingStock` stays at `3` forever, the condition stays `true` forever, and the program prints `Selling unit. Stock: 3` until the process is killed.\n\n**Fix:**\n\n\n```java\npublic class StockFixed {\n public static void main(String[] args) {\n int remainingStock = 3;\n while (remainingStock > 0) {\n System.out.println(\"Selling unit. Stock: \" + remainingStock);\n remainingStock--;\n }\n System.out.println(\"Sold out\");\n }\n}\n```\n\n\nThe fix is one line: `remainingStock--;` inside the body. Now each iteration reduces the value, the condition eventually fails, and the loop exits cleanly.\n\nRun through this checklist for every `while` loop:\n\n- Does the condition refer to a variable?\n- Does the body change that variable?\n- Will that change eventually flip the condition to `false`?\n\nA \"no\" to any of these signals an infinite loop.\n\n### Wrong Initialization\n\nThe other common bug is starting the loop with a value that either skips the body entirely or starts it in a broken state.\n\n**What's wrong with this code?**\n\n\n```java\npublic class PromptBug {\n public static void main(String[] args) {\n int quantity = 1;\n while (quantity < 1) {\n System.out.println(\"Please enter a valid quantity\");\n quantity = 2;\n }\n System.out.println(\"Final quantity: \" + quantity);\n }\n}\n```\n\n\nThe author wanted the prompt to run at least once, but `quantity` starts at `1`, so the condition `quantity < 1` is already `false`. The loop body never runs.\n\n**Fix:**\n\n\n```java\npublic class PromptFixed {\n public static void main(String[] args) {\n int quantity = 0;\n while (quantity < 1) {\n System.out.println(\"Please enter a valid quantity\");\n quantity = 2;\n }\n System.out.println(\"Final quantity: \" + quantity);\n }\n}\n```\n\n\nInitialize to a value that the condition rejects, not one it accepts. The general rule: a `while` loop's starting state and its exit state should be on **opposite sides** of the condition. For the body to run at least once, start outside the condition. For zero iterations to be a valid outcome (like draining an already-empty queue), the loop has to tolerate that.","pageType":"java"}

While Loop

Get Premium