Java for-each Loop: Syntax, Examples, and Gotchas

When the Index Just Gets in the Way

A counted for loop gives you a counter, a condition, and an update step. But a huge amount of the time you do not actually care about the position of an element - you just want to do something with each one, in order, from start to finish. Managing an index for that is busywork, and it is exactly where off-by-one bugs sneak in.

The for-each loop (Java's name for it is the enhanced for) drops the counter entirely. You name a variable, point it at a collection, and the loop hands you each element in turn.

Basic Syntax

The shape is for (Type element : collection). Read the colon as the word "in":

public class Main {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 100};

        for (int score : scores) {
            System.out.println("Score: " + score);
        }
    }
}

There is no i, no scores.length, no scores[i]. On each pass, score is the next element. The loop runs once per element and stops automatically when there are no more - you cannot run past the end or start one element too early.

Looping Over a List

The same loop works on anything iterable, which includes List, Set, and the other collection types. The element type goes before the variable name:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (String lang : langs) {
            System.out.println(lang + " has " + lang.length() + " letters");
        }
    }
}

Notice you did not have to know or care whether langs is backed by an array, a linked list, or anything else - for-each works the same on all of them. That is its real strength: one readable syntax for every collection.

var Saves You the Type Name

If the element type is long or obvious, var lets the compiler infer it so you do not repeat yourself:

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = Map.of("Ann", 30, "Bo", 25);

        for (var entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Without var, that loop variable would be the mouthful Map.Entry<String, Integer>. var keeps it readable, and the type is still fully checked at compile time - this is not a loose, dynamic type.

The Modification Gotcha

Here is the rule that catches everyone: you cannot add to or remove from a collection while a for-each loop is walking it. Doing so throws a ConcurrentModificationException:

List<String> items = new ArrayList<>(List.of("a", "b", "c"));

for (String item : items) {
    if (item.equals("b")) {
        items.remove(item);   // throws ConcurrentModificationException
    }
}

The loop notices the list changed underneath it and bails out rather than silently skipping or repeating elements. To remove safely, drop down to an explicit Iterator, which has a remove() the loop knows about:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>(List.of("a", "b", "c"));

        Iterator<String> it = items.iterator();
        while (it.hasNext()) {
            if (it.next().equals("b")) {
                it.remove();   // safe
            }
        }

        System.out.println(items);   // [a, c]
    }
}

A common shortcut is items.removeIf(item -> item.equals("b")), which uses a lambda expression to do the same thing in one line.

Reading Only, Not Reassigning

Another subtle limit: assigning to the loop variable changes only the local copy, not the collection. This surprises people coming from languages where the loop variable is a live reference:

public class Main {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};

        for (int n : nums) {
            n = n * 10;   // changes the copy, not the array
        }

        System.out.println(nums[0]);   // still 1
    }
}

If you need to write back into the array, you need the index - and that means the classic counted for loop: for (int i = 0; i < nums.length; i++) nums[i] = nums[i] * 10;. For object elements, you can mutate the object the variable points to (calling a setter, say), but you cannot replace it in the collection.

break and continue Still Work

A for-each is a real loop, so break and continue behave exactly as they do elsewhere - break leaves the loop, continue skips to the next element:

public class Main {
    public static void main(String[] args) {
        String[] words = {"keep", "skip", "keep", "stop", "never"};

        for (String w : words) {
            if (w.equals("skip")) continue;   // ignore this one
            if (w.equals("stop")) break;      // quit entirely
            System.out.println(w);
        }
    }
}

This prints keep then keep - it skips "skip" and halts at "stop" before reaching "never". So you are not locked into visiting every element; you just give up the index in exchange for cleaner code.

Next: Arrays

You have now looped over arrays a few times without dwelling on what they actually are - fixed-size, indexed containers with that .length field. The next page goes back to the start and covers arrays properly: declaring them, the default values they start with, and how their fixed size differs from a growable ArrayList.