How for-each works in Java: analysis with examples from beginner to pro

Introduction: why did for-each become the "king" of loops in Java?

If you've been writing Java for at least a week, you've definitely encountered the construct for (Type var : collection). This concise syntax is called the for-each loop (or enhanced for loop). It appeared back in Java 5 (2004) and quickly became a favorite among developers.

But do you know what happens under the hood when the JVM encounters this construct? Why can for-each be slower than a regular for loop for arrays? And why does it sometimes throw ConcurrentModificationException, even if you're not deleting anything?

In this article, we will analyze how for-each works in Java at the bytecode level, compare it with classic loops, and learn how to avoid typical pitfalls. Let's go!

Syntax and first acquaintance

The basic syntax looks like this:

for (ElementType variable : collection_or_array) {\n    // loop body\n}

Example with ArrayList:

List<String> names = Arrays.asList("Anna", "Boris", "Victor");\n\nfor (String name : names) {\n    System.out.println("Hello, " + name + "!");\n}

Output:

Hello, Anna!\nHello, Boris!\nHello, Victor!

Simple, right? Yes. But behind this simplicity lie two completely different mechanisms — for arrays and for collections.

How does for-each work with arrays?

When you write a for-each loop for an array, the Java compiler turns it into a regular index-based for loop. No magic.

Your code:

int[] numbers = {10, 20, 30};\n\nfor (int num : numbers) {\n    System.out.println(num);\n}

After compilation (decompile the bytecode — check for yourself):

int[] numbers = new int[]{10, 20, 30};\nfor (int i = 0; i < numbers.length; i++) {\n    int num = numbers[i];\n    System.out.println(num);\n}

Important conclusion: for arrays, for-each and the regular for loop are the same in terms of performance. No iterator overhead.

How does for-each work with collections (List, Set)?

Now here's where it gets interesting. For collections, for-each uses an iterator.

Your code:

List<String> list = new ArrayList<>();\nlist.add("Java");\nlist.add("Python");\nlist.add("C++");\n\nfor (String lang : list) {\n    System.out.println(lang);\n}

The compiler transforms this into:

List<String> list = new ArrayList<>();\nlist.add("Java");\nlist.add("Python");\nlist.add("C++");\n\nfor (Iterator<String> it = list.iterator(); it.hasNext(); ) {\n    String lang = it.next();\n    System.out.println(lang);\n}

That is:

\n
• list.iterator() is called — we get an iterator.
\n
• The condition is it.hasNext().
\n
• In the body — it.next().
\n
• The variable lang is initialized with the result of next().
\n

What does this mean in practice?

\n
• You cannot remove elements inside a for-each loop using list.remove() — you will get a ConcurrentModificationException. Use it.remove() or a regular for loop.
\n
• You cannot modify the collection (add/remove) during iteration — same error.
\n
• Performance: for ArrayList, the difference from a regular for loop is minimal (creating an iterator object). For LinkedList — for-each is much faster than for (int i = 0; i < list.size(); i++), because get(i) for LinkedList is O(n) each time!
\n

What about Map? Iterating over key-value pairs

Map does not directly implement Iterable, so for-each