{"title":"For Loop","description":"","content":"The `for` loop is Java's workhorse for any task with a known iteration count. Counting through cart items, scanning a list of product ratings, generating order numbers, the `for` loop handles all of it with one compact piece of syntax. This lesson covers the classic counted form, how each part is evaluated, and the small mistakes that come up most often.\n\n---\n\n# Anatomy of a For Loop\n\nA `for` loop has three parts inside the parentheses, separated by semicolons, followed by a body in braces.\n\n\n```java\npublic class FirstForLoop {\n public static void main(String[] args) {\n for (int orderNumber = 1; orderNumber <= 5; orderNumber++) {\n System.out.println(\"Processing order #\" + orderNumber);\n }\n }\n}\n```\n\n\nThe three parts are:\n\n\n| Part | Name | Purpose |\n| ---- | ---- | ------- |\n| `int orderNumber = 1` | Initialization | Runs once, before anything else. Usually declares a counter. |\n| `orderNumber <= 5` | Condition | Checked before each iteration. If `true`, the body runs. If `false`, the loop ends. |\n| `orderNumber++` | Update | Runs after the body, before the next condition check. Usually advances the counter. |\n\n\nThe order of evaluation matters. On the first pass, Java runs the initialization, checks the condition, runs the body, runs the update, then checks the condition again. From the second pass onward, it's just condition, body, update, repeat.\n\n\n```mermaid\nflowchart TD\n A[Start]:::cyan --> B[Run initialization
int orderNumber = 1]:::orange\n B --> C{Check condition
orderNumber lessOrEqual 5}:::yellow\n C -- true --> D[Execute body
print order number]:::teal\n D --> E[Run update
orderNumber++]:::orange\n E --> C\n C -- false --> F[Exit loop]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef yellow fill:#ffd43b,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nAn important detail: the condition is checked **before** the body, not after. If the condition is `false` on the very first check, the body never runs at all. This means a `for` loop is safe to use when the count might be zero.\n\n\n```java\npublic class EmptyCart {\n public static void main(String[] args) {\n int cartSize = 0;\n for (int i = 0; i < cartSize; i++) {\n System.out.println(\"This never prints\");\n }\n System.out.println(\"Loop finished, cart was empty.\");\n }\n}\n```\n\n\n---\n\n# Iterating Over an Array\n\nCounting from `0` to `length - 1` is a common loop shape in Java because it lines up with how arrays are indexed. A small `int[]` shows the pattern.\n\n\n```java\npublic class CartPrices {\n public static void main(String[] args) {\n int[] prices = {29, 49, 19, 99, 15};\n int total = 0;\n for (int i = 0; i < prices.length; i++) {\n System.out.println(\"Item \" + i + \": $\" + prices[i]);\n total = total + prices[i];\n }\n System.out.println(\"Cart total: $\" + total);\n }\n}\n```\n\n\nJava arrays are zero-indexed, so the first item lives at index `0` and the last lives at index `length - 1`. The condition uses `<`, not `<=`. If you wrote `i <= prices.length`, the loop would try to read `prices[5]`, which doesn't exist, and Java would throw `ArrayIndexOutOfBoundsException`.\n\nThe name `i` is fine here. It's the universally recognized convention for a loop index, and using it for that role keeps your code readable. Use a descriptive name when the counter represents something meaningful in the domain, like `orderNumber` or `attemptCount`.\n\n---\n\n# Counting Down and Custom Steps\n\nThe update part doesn't have to be `i++`. It can be any expression that moves the counter, including decrement, addition, multiplication, or anything else.\n\nCounting down is just as easy as counting up. Flip the starting value, flip the condition, and use `--` instead of `++`.\n\n\n```java\npublic class CountdownLaunch {\n public static void main(String[] args) {\n for (int seconds = 5; seconds >= 1; seconds--) {\n System.out.println(\"Launching in \" + seconds + \"...\");\n }\n System.out.println(\"Order placed!\");\n }\n}\n```\n\n\nYou can also step by more than one. A loop that prints every other rating value from 1 to 10:\n\n\n```java\npublic class OddRatings {\n public static void main(String[] args) {\n for (int rating = 1; rating <= 10; rating = rating + 2) {\n System.out.println(\"Rating bucket: \" + rating);\n }\n }\n}\n```\n\n\nThe update `rating = rating + 2` could also be written as `rating += 2`. Both do the same thing.\n\nThe update runs once per iteration. If you put something expensive in there (a method call, a string concatenation), that cost multiplies by the number of iterations. Prefer to keep the update to a simple arithmetic step.\n\n---\n\n# Multiple Init and Update Expressions\n\nBoth the initialization and the update sections accept a comma-separated list. You can declare more than one counter and advance more than one at a time. The condition stays a single boolean expression.\n\nThe classic use case is walking from both ends of a structure toward the middle.\n\n\n```java\npublic class TwoPointers {\n public static void main(String[] args) {\n int[] ratings = {1, 2, 3, 4, 5, 6, 7, 8};\n for (int left = 0, right = ratings.length - 1; left < right; left++, right--) {\n System.out.println(\"Pair: \" + ratings[left] + \" and \" + ratings[right]);\n }\n }\n}\n```\n\n\n`left` starts at `0` and `right` starts at the last valid index. Each pass moves them toward each other. When they meet or cross, the condition becomes `false` and the loop ends.\n\nA few rules to remember about multi-variable `for` loops:\n\n- All variables declared in the init part must be the same type. You can't write `int i = 0, double price = 0.0`.\n- The condition is one boolean expression. To combine conditions, use `&&` or `||`.\n- The update is a list of statements separated by commas, not a list of values. `i++, j--` is fine. `i + 1, j - 1` is not, because those aren't statements.\n\nMulti-variable loops are powerful but easy to overuse. If the loop starts to need three or four counters, it's usually a sign the logic belongs inside the body instead.\n\n---\n\n# Loop Variable Scope\n\nA variable declared in the init part of a `for` loop is **local to that loop**. It does not exist after the loop ends. The compiler enforces this.\n\n\n```java\npublic class ScopedCounter {\n public static void main(String[] args) {\n for (int itemIndex = 0; itemIndex < 3; itemIndex++) {\n System.out.println(\"Index: \" + itemIndex);\n }\n // System.out.println(itemIndex); // Compile error: itemIndex not in scope\n System.out.println(\"Done\");\n }\n}\n```\n\n\nIf you uncomment the line that prints `itemIndex` after the loop, the file won't compile. The compiler reports `cannot find symbol: variable itemIndex` because the name only exists inside the loop's block.\n\nThis is usually what you want. It keeps loop counters from leaking into surrounding code and accidentally being reused. If you do need the final value of the counter after the loop ends, declare the variable outside the loop instead.\n\n\n```java\npublic class CounterAfterLoop {\n public static void main(String[] args) {\n int lastIndex = 0;\n for (lastIndex = 0; lastIndex < 3; lastIndex++) {\n System.out.println(\"Visited index \" + lastIndex);\n }\n System.out.println(\"Loop ended at index \" + lastIndex);\n }\n}\n```\n\n\n`lastIndex` ends up at `3`, not `2`. The update happens after the last iteration that runs the body, and the loop only exits once the condition is `false`. The variable holds the first value that failed the condition.\n\n---\n\n# Off-by-One Bugs\n\nA common bug in any counted loop is being off by one: starting at the wrong index, stopping one step too early, or stopping one step too late. The two usual suspects are the choice between `<` and `<=`, and whether to start at `0` or `1`.\n\n**What's wrong with this code?**\n\n\n```java\npublic class OffByOneBug {\n public static void main(String[] args) {\n int[] prices = {10, 20, 30, 40};\n for (int i = 0; i <= prices.length; i++) {\n System.out.println(prices[i]);\n }\n }\n}\n```\n\n\nThe condition uses `<=` instead of `<`. `prices.length` is `4`, but the valid indices are `0`, `1`, `2`, `3`. When `i` reaches `4`, the code tries to read `prices[4]`, which doesn't exist, and Java throws `ArrayIndexOutOfBoundsException`.\n\n**Fix:**\n\n\n```java\npublic class OffByOneFix {\n public static void main(String[] args) {\n int[] prices = {10, 20, 30, 40};\n for (int i = 0; i < prices.length; i++) {\n System.out.println(prices[i]);\n }\n }\n}\n```\n\n\nThe rule of thumb: when iterating over a structure with `N` elements, use `i = 0; i < N; i++`. The `<` is intentional because indices run from `0` to `N - 1`, and there are exactly `N` of them.\n\nThe other off-by-one is starting at the wrong index.\n\n**What's wrong with this code?**\n\n\n```java\npublic class StartIndexBug {\n public static void main(String[] args) {\n int[] stock = {5, 8, 12, 3};\n int total = 0;\n for (int i = 1; i < stock.length; i++) {\n total = total + stock[i];\n }\n System.out.println(\"Total stock: \" + total);\n }\n}\n```\n\n\nThis loop starts at `i = 1`, skipping the first element. The total only includes `8 + 12 + 3 = 23`, missing the initial `5`. The arithmetic looks right but the answer is wrong, which makes this kind of bug hard to spot.\n\n**Fix:**\n\n\n```java\npublic class StartIndexFix {\n public static void main(String[] args) {\n int[] stock = {5, 8, 12, 3};\n int total = 0;\n for (int i = 0; i < stock.length; i++) {\n total = total + stock[i];\n }\n System.out.println(\"Total stock: \" + total);\n }\n}\n```\n\n\nThere are valid reasons to start at `1` (for example, comparing each item to its previous neighbor), but they should be deliberate, not accidental. When in doubt, start at `0`.\n\n---\n\n# The Infinite For Loop\n\nAll three parts of a `for` loop are optional. Leave them out and you get the infinite loop, written as `for (;;)`. The semicolons are required because the parser uses them to separate the three sections, even when they're empty.\n\n\n```java\npublic class InfiniteLoop {\n public static void main(String[] args) {\n int count = 0;\n for (;;) {\n count++;\n if (count == 3) {\n System.out.println(\"Reached 3, exiting.\");\n break;\n }\n System.out.println(\"Iteration \" + count);\n }\n }\n}\n```\n\n\nWith no condition to check, the loop will run forever unless something inside the body exits it. The usual escape hatches are `break` (jumps out of the loop), `return` (exits the entire method), or throwing an exception. Without one of those, you've created an infinite loop, which will hang your program until you kill it manually.\n\n`for (;;)` is uncommon in everyday Java. The more common way to write an intentional infinite loop is `while (true)`. The `for (;;)` form still shows up in older code and some system-level libraries.","pageType":"java"}

For Loop

Get Premium