{"title":"Labeled Statements","description":"","content":"A plain `break` or `continue` isn't always enough. Searching through a grid of warehouses or scanning a list of carts often requires bailing out of more than just the innermost loop. Java's labeled statements provide that capability: attach a name to a loop, then `break` or `continue` to that name instead of the nearest one. This lesson covers when to use them, how the syntax works, and when an extracted method is the better choice.\n\n---\n\n# What a Label Is\n\nA label is an identifier followed by a colon, placed right before a loop. The label doesn't do anything on its own. It only matters when a `break` or `continue` names it.\n\n\n```java\npublic class LabelSyntax {\n public static void main(String[] args) {\n warehouseSearch:\n for (int aisle = 0; aisle < 3; aisle++) {\n for (int shelf = 0; shelf < 3; shelf++) {\n if (aisle == 1 && shelf == 2) {\n break warehouseSearch;\n }\n System.out.println(\"Checked aisle \" + aisle + \", shelf \" + shelf);\n }\n }\n System.out.println(\"Done\");\n }\n}\n```\n\n\nThe label `warehouseSearch:` sits on the outer `for`. When `break warehouseSearch;` fires, control jumps out of both loops in one step. Without the label, a plain `break` would only exit the inner loop and the outer one would keep going.\n\nNaming rules for labels follow the same rules as variable names: letters, digits, underscores, no leading digit, no keywords. Pick names that describe what the loop is doing. `outer:` works but reads poorly. `warehouseSearch:` or `cartScan:` tells the reader what's going on.\n\nJava has no `goto` keyword. Labels are not a back door to one. They only work with `break` and `continue`, and only to jump out of or skip an enclosing loop. Arbitrary forward or backward jumps to a label are not allowed.\n\n---\n\n# Why Plain `break` Falls Short\n\nTo see why labels exist, look at what a plain `break` does in a nested loop. A plain `break` always exits the **nearest** enclosing loop. That's fine in a single loop. In nested loops, it's often the wrong behavior.\n\n**What's wrong with this code?**\n\n\n```java\npublic class InnerBreakOnly {\n public static void main(String[] args) {\n String[][] inventory = {\n {\"Headphones\", \"Charger\", \"Mouse\"},\n {\"Keyboard\", \"Webcam\", \"Phone Case\"},\n {\"Laptop Stand\", \"USB Hub\", \"Notebook\"}\n };\n String target = \"Webcam\";\n boolean found = false;\n\n for (int aisle = 0; aisle < inventory.length; aisle++) {\n for (int shelf = 0; shelf < inventory[aisle].length; shelf++) {\n if (inventory[aisle][shelf].equals(target)) {\n System.out.println(\"Found \" + target + \" at aisle \" + aisle + \", shelf \" + shelf);\n found = true;\n break;\n }\n }\n System.out.println(\"Finished checking aisle \" + aisle);\n }\n System.out.println(\"Found = \" + found);\n }\n}\n```\n\n\nThe `break` does its job: it leaves the inner loop the instant the product matches. But the outer loop continues, moves on to the next aisle, and keeps printing. Scanning aisle 2 after the answer was already found is wasted work.\n\nThe usual fix without labels is a flag plus an extra check:\n\n\n```java\nfor (int aisle = 0; aisle < inventory.length && !found; aisle++) {\n for (int shelf = 0; shelf < inventory[aisle].length; shelf++) {\n if (inventory[aisle][shelf].equals(target)) {\n found = true;\n break;\n }\n }\n}\n```\n\n\nThat works, but it carries state (`found`) just to coordinate two loops. A labeled break removes the flag.\n\n**Fix with a labeled break:**\n\n\n```java\npublic class LabeledBreakFix {\n public static void main(String[] args) {\n String[][] inventory = {\n {\"Headphones\", \"Charger\", \"Mouse\"},\n {\"Keyboard\", \"Webcam\", \"Phone Case\"},\n {\"Laptop Stand\", \"USB Hub\", \"Notebook\"}\n };\n String target = \"Webcam\";\n\n warehouseSearch:\n for (int aisle = 0; aisle < inventory.length; aisle++) {\n for (int shelf = 0; shelf < inventory[aisle].length; shelf++) {\n if (inventory[aisle][shelf].equals(target)) {\n System.out.println(\"Found \" + target + \" at aisle \" + aisle + \", shelf \" + shelf);\n break warehouseSearch;\n }\n }\n System.out.println(\"Finished checking aisle \" + aisle);\n }\n System.out.println(\"Done\");\n }\n}\n```\n\n\nOne `break warehouseSearch;` exits both loops together. No flag, no extra condition in the outer header, no wasted iterations.\n\n---\n\n# How Labeled `break` Flows\n\nCompare the control flow side by side. A plain `break` exits one level. A labeled `break` exits straight to the statement after the labeled loop, regardless of nesting depth.\n\n\n```mermaid\nflowchart TD\n Start([Start]):::cyan --> Outer{Outer loop
more iterations?}:::orange\n Outer -- No --> AfterOuter[Continue after
outer loop]:::green\n Outer -- Yes --> Inner{Inner loop
more iterations?}:::orange\n Inner -- No --> Outer\n Inner -- Yes --> Body[Do work]:::teal\n Body --> Cond{Condition met?}:::orange\n Cond -- No --> Inner\n Cond -- \"Yes, plain break\" --> AfterInner[Exit inner only
back to outer header]:::red\n Cond -- \"Yes, break label\" --> AfterOuter\n AfterInner --> Outer\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 two red and green endpoints make the difference clear. A plain `break` returns to the outer loop's header to check the next iteration. A labeled `break` goes all the way out, skipping the rest of the outer loop entirely.\n\nThis also extends to three or more levels. With three nested loops and the outermost labeled, `break theOutermost;` from the deepest body exits all three at once.\n\n\n```java\npublic class TripleNested {\n public static void main(String[] args) {\n String[][][] warehouses = {\n { {\"Mouse\", \"Charger\"}, {\"Keyboard\"} },\n { {\"Webcam\", \"Headphones\"}, {\"Phone Case\", \"USB Hub\"} }\n };\n String target = \"USB Hub\";\n\n warehouseScan:\n for (int w = 0; w < warehouses.length; w++) {\n for (int aisle = 0; aisle < warehouses[w].length; aisle++) {\n for (int shelf = 0; shelf < warehouses[w][aisle].length; shelf++) {\n if (warehouses[w][aisle][shelf].equals(target)) {\n System.out.println(\"Found at warehouse \" + w + \", aisle \" + aisle + \", shelf \" + shelf);\n break warehouseScan;\n }\n }\n }\n }\n System.out.println(\"Search complete\");\n }\n}\n```\n\n\n---\n\n# Labeled `continue`\n\n`continue` has the same problem in nested loops, just less common. A plain `continue` jumps to the next iteration of the **nearest** loop, which is the inner one. A labeled `continue` jumps to the next iteration of the **labeled** loop.\n\nThis is useful for skipping the rest of an outer iteration based on something discovered in the inner loop. Consider checking a list of shopping carts and skipping any cart that contains an out-of-stock item.\n\n\n```java\npublic class LabeledContinue {\n public static void main(String[] args) {\n String[][] carts = {\n {\"Headphones\", \"Charger\"},\n {\"Webcam\", \"OUT_OF_STOCK\", \"Mouse\"},\n {\"Keyboard\", \"USB Hub\"}\n };\n\n outerCart:\n for (int c = 0; c < carts.length; c++) {\n for (int i = 0; i < carts[c].length; i++) {\n if (carts[c][i].equals(\"OUT_OF_STOCK\")) {\n System.out.println(\"Cart \" + c + \" has unavailable item, skipping\");\n continue outerCart;\n }\n }\n System.out.println(\"Cart \" + c + \" is ready to ship\");\n }\n }\n}\n```\n\n\nWhen `continue outerCart;` fires for cart 1, control jumps straight to the top of the outer loop and moves on to cart 2. The \"ready to ship\" line below the inner loop never runs for cart 1, because labeled `continue` skips the rest of that outer iteration.\n\nA plain `continue` there would skip to the next item in the same cart, the opposite of the desired behavior.\n\n---\n\n# A Real Search Example\n\nPutting it together, a complete search over a 2D inventory that reports the position of the first match and stops cleanly:\n\n\n```java\npublic class InventoryLookup {\n public static void main(String[] args) {\n String[][] inventory = {\n {\"Headphones\", \"Charger\", \"Mouse\"},\n {\"Keyboard\", \"Webcam\", \"Phone Case\"},\n {\"Laptop Stand\", \"USB Hub\", \"Notebook\"}\n };\n String target = \"Phone Case\";\n\n int foundAisle = -1;\n int foundShelf = -1;\n\n warehouseSearch:\n for (int aisle = 0; aisle < inventory.length; aisle++) {\n for (int shelf = 0; shelf < inventory[aisle].length; shelf++) {\n if (inventory[aisle][shelf].equals(target)) {\n foundAisle = aisle;\n foundShelf = shelf;\n break warehouseSearch;\n }\n }\n }\n\n if (foundAisle == -1) {\n System.out.println(target + \" not in stock\");\n } else {\n System.out.println(target + \" is at aisle \" + foundAisle + \", shelf \" + foundShelf);\n }\n }\n}\n```\n\n\nThe labeled `break` saves the position variables before exiting. That's a typical pattern: exiting a search usually requires remembering **where** the match was found. The variables live in the enclosing scope so they're still readable after the loops finish.\n\nLabeled `break` and `continue` have no runtime overhead. They compile to the same kind of jump as plain `break` and `continue`. The cost is purely in readability, not performance.\n\n---\n\n# Labels Are Rare in Idiomatic Java\n\nLabels are uncommon in everyday Java code. They have legitimate uses (the search example above is one), but most code that uses a label has a clearer alternative: pull the loops into their own method and use `return`.\n\n\n```java\npublic class ExtractedSearch {\n public static void main(String[] args) {\n String[][] inventory = {\n {\"Headphones\", \"Charger\", \"Mouse\"},\n {\"Keyboard\", \"Webcam\", \"Phone Case\"},\n {\"Laptop Stand\", \"USB Hub\", \"Notebook\"}\n };\n int[] position = findProduct(inventory, \"Phone Case\");\n if (position == null) {\n System.out.println(\"Not in stock\");\n } else {\n System.out.println(\"Found at aisle \" + position[0] + \", shelf \" + position[1]);\n }\n }\n\n static int[] findProduct(String[][] inventory, String target) {\n for (int aisle = 0; aisle < inventory.length; aisle++) {\n for (int shelf = 0; shelf < inventory[aisle].length; shelf++) {\n if (inventory[aisle][shelf].equals(target)) {\n return new int[]{aisle, shelf};\n }\n }\n }\n return null;\n }\n}\n```\n\n\n`return` exits any number of nested loops at once. It also gives the search a name (`findProduct`) and makes the result obvious from the type signature. This version usually reads better in code review.\n\nWhen does a label fit? When the loops do real work that touches surrounding state, splitting them into a method would force passing and returning a long list of values, and the logic is clearly tied to where it lives. That's a narrow case, but it does come up.\n\nA reasonable guideline:\n\n- **Prefer extracting a method** when the loop body is self-contained and the search has a clear \"answer\" to return.\n- **Consider a label** when the loops mutate multiple outer variables, splitting them out would require returning a tuple-like object to immediately unpack, and the logic is short enough that the label reads cleanly in place.\n\n---\n\n# Label Placement and Scope\n\nA label has to sit immediately before a statement, and the statement it labels is the only one it applies to. In practice, that statement is almost always a loop (`for`, `while`, or `do-while`). A `{ }` block or a `switch` can technically be labeled, but those uses are rare and usually a sign that something else needs refactoring.\n\nThe label is only visible inside the statement it labels. Break or continue to a label from outside its scope is not allowed. Reusing the same label name for two different loops in the same nesting is also rejected by the compiler.\n\n\n```java\npublic class LabelScope {\n public static void main(String[] args) {\n cartScan:\n for (int c = 0; c < 3; c++) {\n for (int i = 0; i < 3; i++) {\n if (i == 2) {\n continue cartScan;\n }\n System.out.println(\"Cart \" + c + \", item \" + i);\n }\n }\n }\n}\n```\n\n\n`continue cartScan;` ends the current outer iteration as soon as `i` reaches `2`, so item `2` is never printed for any cart.","pageType":"java"}

Labeled Statements

Get Premium