{"title":"Enhanced For Loop","description":"","content":"The classic `for` loop is flexible, but most of the time you just want to walk through every element of an array or list, one at a time. Java 5 added the **enhanced for loop**, also called the **for-each loop**, for exactly that case. It strips away the index bookkeeping and lets you focus on what you're doing with each element.\n\n---\n\n# The Syntax\n\nThe enhanced for loop reads like English: \"for each item in this collection, do the following.\"\n\n\n```java\nfor (Type item : iterable) {\n // use item\n}\n```\n\n\nYou declare a variable that holds the current element, follow it with a colon, and then name the thing you're iterating over. On each pass, `item` is set to the next element. The loop ends when there are no more elements.\n\nHere's the contrast with a classic `for` loop. Both print every product in a cart:\n\n\n```java\npublic class CartPrinter {\n public static void main(String[] args) {\n String[] cartItems = {\"Wireless Headphones\", \"USB Cable\", \"Phone Case\"};\n\n // Classic for loop\n for (int i = 0; i < cartItems.length; i++) {\n System.out.println(cartItems[i]);\n }\n\n System.out.println(\"---\");\n\n // Enhanced for loop\n for (String cartItem : cartItems) {\n System.out.println(cartItem);\n }\n }\n}\n```\n\n\nThe enhanced version is shorter and harder to get wrong. There is no `i = 0` to remember, no `i < cartItems.length` to type, no `cartItems[i]` to look up. The loop variable `cartItem` is the element itself, not an index pointing to it.\n\nThe enhanced for loop was introduced in Java 5 (2004). Every modern Java codebase uses it.\n\n---\n\n# How It Walks Through an Array\n\nThe flow is simple: pick the next element, assign it to the loop variable, run the body, repeat.\n\n\n```mermaid\nflowchart LR\n A[Start]:::cyan --> B[More elements?]:::orange\n B -- Yes --> C[Assign next
element to
loop variable]:::teal\n C --> D[Run loop body]:::green\n D --> B\n B -- No --> E[End]:::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\nThere's no counter exposed to your code. The loop knows how many elements remain because the array or collection knows its own size, but you never see that number unless you ask.\n\nA more realistic example: summing the prices in a cart.\n\n\n```java\npublic class CartTotal {\n public static void main(String[] args) {\n double[] prices = {19.99, 4.50, 29.95, 9.99};\n double total = 0;\n for (double price : prices) {\n total += price;\n }\n System.out.println(\"Cart total: $\" + total);\n }\n}\n```\n\n\nThe loop reads naturally: \"for each price in prices, add it to the total.\"\n\n---\n\n# Works on Anything Iterable\n\nThe enhanced for loop isn't just for arrays. It works on anything that implements the `Iterable` interface, which includes `List`, `Set`, and most of the standard collection types you'll encounter later.\n\nYou can think of it like this: if a type can hand out its elements one at a time, the enhanced for loop can walk it.\n\n\n```java\nimport java.util.List;\n\npublic class OrderStatusPrinter {\n public static void main(String[] args) {\n List orderStatuses = List.of(\"placed\", \"shipped\", \"delivered\");\n for (String status : orderStatuses) {\n System.out.println(\"Order status: \" + status);\n }\n }\n}\n```\n\n\nThe body of the loop looks identical to the array version. The same syntax handles arrays, lists, and sets without you having to think about it.\n\n---\n\n# When the Classic `for` Loop Wins\n\nThe enhanced version is cleaner, but it gives up some power in exchange. There are four situations where you'll want to go back to the classic `for` loop.\n\n### 1. You Need the Current Index\n\nThe enhanced for loop hides the index from you. If you need to know whether you're on the first item, the last item, or position `i`, you don't have access to that number directly.\n\nSay you want to print a numbered list of cart items:\n\n\n```java\npublic class NumberedCart {\n public static void main(String[] args) {\n String[] cartItems = {\"Wireless Headphones\", \"USB Cable\", \"Phone Case\"};\n for (int i = 0; i < cartItems.length; i++) {\n System.out.println((i + 1) + \". \" + cartItems[i]);\n }\n }\n}\n```\n\n\nYou can fake the index with a separate counter variable inside an enhanced for loop, but at that point the classic version is just clearer.\n\n### 2. You Want to Iterate in Reverse\n\nThe enhanced for loop always goes from first to last. There's no \"iterate backwards\" mode. If you need to walk an array from the end to the beginning, you need a classic `for` loop with a decrementing counter.\n\n\n```java\npublic class ReversedItems {\n public static void main(String[] args) {\n String[] cartItems = {\"Wireless Headphones\", \"USB Cable\", \"Phone Case\"};\n for (int i = cartItems.length - 1; i >= 0; i--) {\n System.out.println(cartItems[i]);\n }\n }\n}\n```\n\n\n### 3. You Want to Walk Two Arrays Together\n\nThe enhanced for loop iterates one thing at a time. If you have product names in one array and prices in a parallel array, and you want to print them side by side, the enhanced version can't do that on its own. You need an index to look into both.\n\n\n```java\npublic class ProductPriceList {\n public static void main(String[] args) {\n String[] productNames = {\"Wireless Headphones\", \"USB Cable\", \"Phone Case\"};\n double[] productPrices = {49.99, 4.50, 14.95};\n for (int i = 0; i < productNames.length; i++) {\n System.out.println(productNames[i] + \": $\" + productPrices[i]);\n }\n }\n}\n```\n\n\n### 4. You Want to Modify the Collection Structurally\n\nYou can't safely add or remove elements from a list while you're iterating it with an enhanced for loop. If you try, you'll get a `ConcurrentModificationException` at runtime.\n\n---\n\n# Reassigning the Loop Variable Does Nothing\n\nHere's a trap that catches beginners. The loop variable is a **copy** of the element, not a reference back into the array. Reassigning it doesn't change the array.\n\n**What's wrong with this code?**\n\n\n```java\npublic class BrokenDiscount {\n public static void main(String[] args) {\n double[] prices = {19.99, 4.50, 29.95};\n for (double price : prices) {\n price = price * 0.9; // 10% discount, right?\n }\n for (double price : prices) {\n System.out.println(price);\n }\n }\n}\n```\n\n\nThe discount didn't apply. The variable `price` is a local copy of each array element. When you reassign `price`, you change the copy, not the array slot it came from. Java passes values, not slots, into the loop variable.\n\n**Fix:** Use a classic `for` loop with an index so you can write back into the array.\n\n\n```java\npublic class FixedDiscount {\n public static void main(String[] args) {\n double[] prices = {19.99, 4.50, 29.95};\n for (int i = 0; i < prices.length; i++) {\n prices[i] = prices[i] * 0.9;\n }\n for (double price : prices) {\n System.out.println(price);\n }\n }\n}\n```\n\n\n`prices[i] = ...` writes back into the array. Now the change sticks.\n\nThe same rule applies to primitives in any context: assigning to a copy never affects the original. With objects the story is more nuanced (you can still call methods that mutate the object the reference points to), but reassigning the loop variable itself never updates the array slot.\n\n---\n\n# Putting It Together\n\nHere's a slightly bigger example that combines a few ideas. Given a list of product ratings, compute the average rating and count how many are 5-star reviews.\n\n\n```java\npublic class RatingsReport {\n public static void main(String[] args) {\n int[] ratings = {5, 4, 5, 3, 5, 2, 4, 5};\n int sum = 0;\n int fiveStarCount = 0;\n for (int rating : ratings) {\n sum += rating;\n if (rating == 5) {\n fiveStarCount++;\n }\n }\n double average = (double) sum / ratings.length;\n System.out.println(\"Average rating: \" + average);\n System.out.println(\"Five-star reviews: \" + fiveStarCount);\n }\n}\n```\n\n\nThe enhanced for loop handles the traversal. The accumulator variables (`sum`, `fiveStarCount`) live outside the loop, get updated inside, and we read their final values afterward. No index needed, because we don't care about position.","pageType":"java"}

Enhanced For Loop

Get Premium