{"title":"Break & Continue","description":"","content":"Loops are great when you want to process every element, but real code often needs to stop early or skip an iteration. That's what `break` and `continue` are for. This lesson covers the unlabeled forms of both keywords, how they behave inside `for`, `while`, and `do-while`, and the common bugs that come with them.\n\n---\n\n# What `break` Does\n\n`break` immediately exits the nearest enclosing loop. The loop's condition check is not run again, the update step (if any) is skipped, and execution jumps to the first statement after the loop.\n\nThe most common use is \"find the first match and stop.\" Once you've found what you were looking for, scanning the rest of the array is wasted work.\n\n\n```java\npublic class FindFirstInStock {\n public static void main(String[] args) {\n String[] products = {\"Headphones\", \"Keyboard\", \"Mouse\", \"Monitor\"};\n int[] stock = {0, 0, 12, 5};\n\n int firstAvailableIndex = -1;\n for (int i = 0; i < products.length; i++) {\n if (stock[i] > 0) {\n firstAvailableIndex = i;\n break;\n }\n }\n\n if (firstAvailableIndex >= 0) {\n System.out.println(\"First in-stock product: \" + products[firstAvailableIndex]);\n } else {\n System.out.println(\"Everything is out of stock\");\n }\n }\n}\n```\n\n\nThe loop walks through products in order. When it hits index `2` (`Mouse`, stock `12`), the condition is true, it records the index, and `break` ends the loop right there. Indexes `3` is never visited.\n\n`break` also exits a `switch` statement. That's the same keyword doing the same job: leave the nearest enclosing `switch` or loop. If you write `break` inside a `switch` that's inside a `for`, it exits the `switch`, not the `for`.\n\n---\n\n# What `continue` Does\n\n`continue` skips the rest of the current iteration and jumps to the next condition check. In a `for` loop, the update step runs before that check, so `i++` (or whatever you put there) still happens.\n\nThe standard use is \"skip the items you don't care about\" without writing a deeply nested `if`.\n\n\n```java\npublic class SkipOutOfStock {\n public static void main(String[] args) {\n String[] products = {\"Headphones\", \"Keyboard\", \"Mouse\", \"Monitor\"};\n int[] stock = {3, 0, 12, 0};\n\n int processedCount = 0;\n for (int i = 0; i < products.length; i++) {\n if (stock[i] == 0) {\n continue;\n }\n System.out.println(products[i] + \" is available (\" + stock[i] + \" in stock)\");\n processedCount++;\n }\n System.out.println(\"Processed \" + processedCount + \" in-stock products\");\n }\n}\n```\n\n\nWhen `stock[i]` is `0`, `continue` jumps straight to the update step (`i++`) and then re-checks the condition. The print line and the counter increment are skipped for those iterations.\n\nYou could write the same logic with `if (stock[i] > 0) { ... }`, and for one condition it reads about the same. `continue` is more useful when you have several \"skip this one\" checks at the top of a loop body. Each one becomes a flat guard instead of nesting deeper.\n\n---\n\n# A Visual View of Control Flow\n\nBoth keywords change where execution goes next. The diagram below shows how they redirect a loop's normal flow.\n\n\n```mermaid\nflowchart TD\n A[Start loop]:::cyan --> B{Condition true?}:::orange\n B -- No --> Z[Exit loop]:::red\n B -- Yes --> C[Run loop body]:::teal\n C --> D{continue?}:::orange\n D -- Yes --> E[Skip rest of body]:::green\n D -- No --> F{break?}:::orange\n F -- Yes --> Z\n F -- No --> G[Finish body normally]:::teal\n G --> H[Run update step
for-loop only]:::cyan\n E --> H\n H --> B\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 key takeaway: `continue` loops back to the condition check (after running the update step in a `for`), while `break` leaves the loop entirely. Neither one re-runs the body of the current iteration.\n\n---\n\n# `break` and `continue` in `while`\n\nIn a `while` loop, `continue` jumps to the condition check at the top. There's no update step that runs automatically.\n\nHere's a clean example: read inputs until you hit a sentinel value, validating each one. `break` lets us exit the loop cleanly on the stop signal.\n\n\n```java\npublic class ValidateInputs {\n public static void main(String[] args) {\n String[] inputs = {\"29.99\", \"abc\", \"15.50\", \"stop\", \"9.99\"};\n int index = 0;\n double total = 0;\n\n while (index < inputs.length) {\n String raw = inputs[index];\n index++;\n\n if (raw.equals(\"stop\")) {\n break;\n }\n\n try {\n double price = Double.parseDouble(raw);\n total += price;\n } catch (NumberFormatException e) {\n System.out.println(\"Skipping invalid input: \" + raw);\n continue;\n }\n\n System.out.println(\"Added \" + raw);\n }\n\n System.out.println(\"Final total: $\" + total);\n }\n}\n```\n\n\nTwo details. `break` ends the loop as soon as we see `\"stop\"`. The `\"9.99\"` that comes after is never processed. The `continue` here is technically optional because there's nothing after it in the loop body, but it makes the intent clear: \"we're done with this iteration.\"\n\n---\n\n# The `continue` Infinite Loop Trap\n\n`continue` in a `while` loop is dangerous when the counter or state change happens **after** the condition you're skipping on. If you `continue` past the update, the loop spins on the same value forever.\n\n**What's wrong with this code?**\n\n\n```java\npublic class BrokenSkip {\n public static void main(String[] args) {\n int[] stock = {3, 0, 12, 0, 5};\n int index = 0;\n int totalAvailable = 0;\n\n while (index < stock.length) {\n if (stock[index] == 0) {\n continue;\n }\n totalAvailable += stock[index];\n index++;\n }\n\n System.out.println(\"Total available: \" + totalAvailable);\n }\n}\n```\n\n\nThis program never prints anything. It hangs. When `index` is `1`, `stock[1]` is `0`, so `continue` jumps back to the `while` condition. But `index` was never incremented, so `stock[1]` is still `0`, so `continue` runs again, and again, and again.\n\n**Fix:**\n\n\n```java\npublic class FixedSkip {\n public static void main(String[] args) {\n int[] stock = {3, 0, 12, 0, 5};\n int index = 0;\n int totalAvailable = 0;\n\n while (index < stock.length) {\n int current = stock[index];\n index++;\n if (current == 0) {\n continue;\n }\n totalAvailable += current;\n }\n\n System.out.println(\"Total available: \" + totalAvailable);\n }\n}\n```\n\n\nThe fix: increment `index` **before** the `continue` can fire. Now every iteration moves forward, no matter which path runs. A `for` loop avoids this trap entirely because its update step runs even on `continue`. Prefer `for` when walking through an index.\n\n---\n\n# `break` and `continue` in `do-while`\n\nA `do-while` runs the body at least once, then checks the condition at the bottom. `break` and `continue` behave the same way they do in `while`: `break` leaves the loop entirely, `continue` jumps to the condition check at the bottom.\n\nThis order-status scanner walks through orders until it finds the first one with status `\"pending\"`, then stops.\n\n\n```java\npublic class FindFirstPending {\n public static void main(String[] args) {\n String[] orderStatuses = {\"shipped\", \"delivered\", \"pending\", \"shipped\"};\n int index = 0;\n int firstPendingIndex = -1;\n\n do {\n if (orderStatuses[index].equals(\"pending\")) {\n firstPendingIndex = index;\n break;\n }\n index++;\n } while (index < orderStatuses.length);\n\n if (firstPendingIndex >= 0) {\n System.out.println(\"First pending order at index: \" + firstPendingIndex);\n } else {\n System.out.println(\"No pending orders found\");\n }\n }\n}\n```\n\n\nThe body runs, checks the status, and either increments `index` or breaks. The same trap applies as in `while`: a `continue` before incrementing `index` hangs the loop. The condition runs at the bottom, but the update is still your responsibility.\n\n---\n\n# Common Use Cases\n\nA few patterns come up often enough that it's worth naming them.\n\n\n| Pattern | What `break`/`continue` does | Example |\n|---------|------------------------------|---------|\n| Early exit on found item | `break` after recording the match | Find first in-stock product |\n| Skip invalid items | `continue` past records that fail a check | Skip out-of-stock products in a price calculation |\n| Validation short-circuit | `break` on first bad input | Stop reading prices on a parse error |\n| Bounded retry | `break` after a successful attempt | Retry a flaky check up to N times |\n\n\nHere's the validation short-circuit pattern in full. The moment we hit an invalid input, we bail out instead of silently ignoring it.\n\n\n```java\npublic class ShortCircuitValidation {\n public static void main(String[] args) {\n String[] rawPrices = {\"19.99\", \"29.50\", \"free\", \"9.99\"};\n double total = 0;\n boolean allValid = true;\n\n for (int i = 0; i < rawPrices.length; i++) {\n try {\n total += Double.parseDouble(rawPrices[i]);\n } catch (NumberFormatException e) {\n System.out.println(\"Invalid price at position \" + i + \": \" + rawPrices[i]);\n allValid = false;\n break;\n }\n }\n\n if (allValid) {\n System.out.println(\"All prices valid. Total: $\" + total);\n } else {\n System.out.println(\"Validation failed. Partial total: $\" + total);\n }\n }\n}\n```\n\n\nThe `break` here is doing real work: it stops the loop the moment we know the answer isn't going to be useful. Without it, the loop would keep running and either keep totaling valid prices or throw on the next bad one.\n\n---\n\n# When to Step Back from `break` and `continue`\n\n`break` and `continue` are tools, not goals. A loop body that has two or three `continue` guards plus a `break` in the middle plus a nested `if` is hard to follow. The reader has to mentally trace every branch to know what reaches the end.\n\nNested loops with `break` and `continue` scattered through them are usually a sign to pull the logic into a method. A method with a clear name and a single `return` is almost always easier to read than a deeply nested loop with control jumps. The rule of thumb: if a loop body is longer than the screen, or has more than two `break`/`continue` statements, consider extracting part of it.\n\n---\n\n# A Teaser: Breaking Out of Nested Loops\n\nPlain `break` only exits the nearest enclosing loop. That gets awkward when you have a nested loop and you want to break out of both at once. Java has a feature called **labels** that lets you tell `break` or `continue` exactly which loop to target.","pageType":"java"}

Break & Continue

Get Premium