The Enhanced for Loop

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

for-each loop

Another name for the enhanced for loop: do something for each element.

Element

One item stored in an array or collection.

Iterable

A Java interface for anything that can hand out its elements one by one. List and Set are Iterable.

Iterator

An object that walks through a collection: hasNext() asks 'is there another?', next() gives it.

Reference

The address of an object on the heap. Object variables hold references, not the objects themselves (Topic 3.11).

ConcurrentModificationException

The error an ArrayList (and most collections) throws when it's changed while an iterator is walking it.

Desugaring

The compiler rewriting a convenient piece of syntax into simpler code it already understands.

1. 1

   Trigger the exception

   In 'Removing safely', change "Bob" to "Ana" in the first loop. Predict what happens, then run. You now get ConcurrentModificationException, because the loop calls next() again after the removal.

2. 2

   Prove the copy

   In 'The loop variable is a copy', add final to the first loop: for (final int x : numbers). Compile. The assignment x = x * 10 is now an error (cannot assign a value to final variable x), which is exactly the safety net teams want.

3. 3

   Loop a map

   In 'Lists, sets and maps', add stock.put("glue", 7); and predict where it appears in the output. (A TreeMap keeps keys sorted, so glue comes first.)

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

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

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Ana", "Bob", "Cy", "Dee"));
        for (String name : names) {
            if (name.startsWith("A")) {
                names.remove(name);
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int[] scores = null;
        for (int s : scores) {
            System.out.println(s);
        }
    }
}

1. 1

   The syntax is for (int score : scores), read aloud as 'for each score in scores'. Java runs the body once per element, in order, putting the current element into score each time. It's also called the for-each loop and arrived in Java 5.

2. 2

   It works on two kinds of things: arrays, and any object that implements Iterable (every List, Set and Queue from the collections framework, Phase 9). For a Map, loop over map.entrySet(), keySet() or values(). A String isn't Iterable; loop over str.toCharArray() instead.

3. 3

   There's no index, so it can't go out of bounds, but you also can't tell which position you're at, skip ahead, walk backwards, look at the neighbour arr[i + 1], or walk two arrays side by side. For those, use the classic for (Topic 2.6).

4. 4

   The loop variable is a copy of the element. Assigning to it (score = 0) changes the copy, not the array. For objects, the copy is a copy of the reference (Topic 3.3), so calling a method that changes the object (sb.append("!")) does affect the element, while reassigning the variable doesn't.

5. 5

   You must not change a collection's structure (add or remove elements) while for-each is walking it. ArrayList notices and throws ConcurrentModificationException. Use Iterator.remove(), removeIf (Java 8), or build a new list.

6. 6

   The compiler rewrites the loop: over an array it becomes an index loop on a hidden copy of the array reference; over an Iterable it becomes Iterator it = list.iterator(); while (it.hasNext()) { T x = it.next(); ... }. Knowing this explains every rule above.

• ↔

  For-each removes index bugs and reads like English, but hides the position and can't modify slots or remove elements safely.

• ↔

  For-each over a List works for every implementation in O(n); an index loop is O(n) on ArrayList but O(n²) on LinkedList.

• ↔

  removeIf and streams (Phase 11) express filtering more directly than loops, but a plain for-each is easier to debug step by step.

• Done when you can loop over arrays, lists, sets and map entries with for-each.

• Done when you can explain why assigning to the loop variable doesn't change the array.

• Done when you can write the desugared form of for-each over an array and over an Iterable.

• Done when you can remove elements safely with Iterator.remove() or removeIf.

• Done when you can say when a classic for loop is required instead.