Edit - Stack Overflow

You are not logged in. Your edit will be placed in a queue until it is peer reviewed.

We welcome edits that make the post easier to understand and more valuable for readers. Because community members review edits, please try to make the post substantially better than how you found it, for example, by fixing grammar or adding additional resources and hyperlinks.

Required fields*

Rev

Required fields*

In detail, how does the 'for each' loop work in Java?

Consider:

List<String> someList = new ArrayList<>();
// add "monkey", "donkey", "skeleton key" to someList

for (String item : someList) {
    System.out.println(item);
}

What would the equivalent for loop look like without using the for each syntax?

_{People new to Java commonly encounter issues when trying to modify the original data using the new style foreach loop. Use Why doesn't assigning to the iteration variable in a foreach loop change the underlying data? to close duplicates about that common problem. Note that other languages with analogous constructs generally have the same issue; for example, see Why doesn't modifying the iteration variable affect subsequent iterations? for the same issue in Python.}

Answer*

The [for-each loop][1], added in [Java 5][2] (also called the "enhanced for loop"), is equivalent to using a [`java.util.Iterator`][3]--it's syntactic sugar for the same thing. Therefore, when reading each element, one by one and in order, a for-each should always be chosen over an iterator, as it is more convenient and concise.

### For-each

    for (int i : intList) {
       System.out.println("An element in the list: " + i);
    }

### Iterator

    Iterator<Integer> intItr = intList.iterator();
    while (intItr.hasNext()) {
       System.out.println("An element in the list: " + intItr.next());
    }

There are situations where you must use an `Iterator` directly. For example, attempting to delete an element while using a for-each can (will?) result in a `ConcurrentModificationException`.

## For-each vs. for-loop: Basic differences

The only practical difference between for-loop and for-each is that, in the case of indexable objects, you do not have access to the index. An example when the basic for-loop is required:

    for (int i = 0; i < array.length; i++) {
       if(i < 5) {
          // Do something special
       }  else {
          // Do other stuff
       }
    }

Although you could manually create a separate index int-variable with for-each,

    int idx = -1;
    for (int i : intArray) {
       idx++;
       ...
    }

...it is not recommended, since [variable-scope][4] is not ideal, and the basic `for` loop is simply the standard and expected format for this use case.

## For-each vs. for-loop: Performance

When accessing collections, a for-each is [significantly faster][5] than the basic `for` loop's array access. When accessing arrays, however--at least with primitive and wrapper-arrays--access via indexes is dramatically faster.

### Timing the difference between iterator and index access for primitive int-arrays

Indexes are 23-*40* percent faster than iterators when accessing `int` or `Integer` arrays. Here is the output from the testing class at the bottom of this post, which sums the numbers in a 100-element primitive-int array (A is iterator, B is index):

```lang-none
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 358,597,622 nanoseconds
Test B: 269,167,681 nanoseconds
B faster by 89,429,941 nanoseconds (24.438799231635727% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 377,461,823 nanoseconds
Test B: 278,694,271 nanoseconds
B faster by 98,767,552 nanoseconds (25.666236154695838% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 288,953,495 nanoseconds
Test B: 207,050,523 nanoseconds
B faster by 81,902,972 nanoseconds (27.844689860906513% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,373,765 nanoseconds
Test B: 283,813,875 nanoseconds
B faster by 91,559,890 nanoseconds (23.891659337194227% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,790,818 nanoseconds
Test B: 220,770,915 nanoseconds
B faster by 155,019,903 nanoseconds (40.75164734599769% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 326,373,762 nanoseconds
Test B: 202,555,566 nanoseconds
B faster by 123,818,196 nanoseconds (37.437545972215744% faster)
```

I also ran this for an `Integer` array, and indexes are still the clear winner, but only between 18 and 25 percent faster.

### For collections, iterators are faster than indexes

For a `List` of `Integers`, however, iterators are the clear winner. Just change the int-array in the test-class to:

    List<Integer> intList = Arrays.asList(new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100});

And make the necessary changes to the test-function (`int[]` to `List<Integer>`, `length` to `size()`, etc.):

```lang-none
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,429,929,976 nanoseconds
Test B: 5,262,782,488 nanoseconds
A faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,907,391,427 nanoseconds
Test B: 3,957,718,459 nanoseconds
A faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,566,004,688 nanoseconds
Test B: 4,221,746,521 nanoseconds
A faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,770,945,276 nanoseconds
Test B: 3,829,077,158 nanoseconds
A faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,467,474,055 nanoseconds
Test B: 5,183,149,104 nanoseconds
A faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,439,983,933 nanoseconds
Test B: 3,509,530,312 nanoseconds
A faster by 69,546,379 nanoseconds (1.4816434912159906% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,451,101,466 nanoseconds
Test B: 5,057,979,210 nanoseconds
A faster by 1,606,877,744 nanoseconds (31.269164666060377% faster)
```

In one test they're almost equivalent, but with collections, iterator wins.

*This post is based on two answers I wrote on Stack Overflow:

 * *[Uses and syntax for for-each loop in Java][6]*

 * *https://stackoverflow.com/questions/22540025/should-i-use-an-iterator-or-a-forloop-to-iterate/22540191#22540191*

Some more information: *https://stackoverflow.com/questions/2113216/which-is-more-efficient-a-for-each-loop-or-an-iterator*

### The full testing class

I created this compare-the-time-it-takes-to-do-any-two-things class after reading [this question][7] on Stack Overflow:

    import  java.text.NumberFormat;
    import  java.util.Locale;

    /**
       &lt;P&gt;{@code java TimeIteratorVsIndexIntArray 1000000}&lt;/P&gt;

       @see  &lt;CODE&gt;&lt;A HREF=&quot;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&lt;/A&gt;&lt;/CODE&gt;
     **/
    public class TimeIteratorVsIndexIntArray {

        public static final NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);

        public static final void main(String[] tryCount_inParamIdx0) {
            int testCount;

            // Get try-count from a command-line parameter
            try {
               testCount = Integer.parseInt(tryCount_inParamIdx0[0]);
            }
            catch(ArrayIndexOutOfBoundsException | NumberFormatException x) {
               throw  new IllegalArgumentException("Missing or invalid command line parameter: The number of testCount for each test. " + x);
            }

            //Test proper...START
            int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100};

            long lStart = System.nanoTime();
            for(int i = 0; i < testCount; i++) {
               testIterator(intArray);
            }

            long lADuration = outputGetNanoDuration("A", lStart);

            lStart = System.nanoTime();
            for(int i = 0; i < testCount; i++) {
               testFor(intArray);
            }

            long lBDuration = outputGetNanoDuration("B", lStart);

            outputGetABTestNanoDifference(lADuration, lBDuration, "A", "B");
        }

        private static final void testIterator(int[] int_array) {
           int total = 0;
           for(int i = 0; i < int_array.length; i++) {
              total += int_array[i];
           }
        }

        private static final void testFor(int[] int_array) {
           int total = 0;
           for(int i : int_array) {
              total += i;
           }
        }
        //Test proper...END

        //Timer testing utilities...START
        public static final long outputGetNanoDuration(String s_testName, long l_nanoStart) {
            long lDuration = System.nanoTime() - l_nanoStart;
            System.out.println("Test " + s_testName + ": " + nf.format(lDuration) + " nanoseconds");
            return  lDuration;
        }

        public static final long outputGetABTestNanoDifference(long l_aDuration, long l_bDuration, String s_aTestName, String s_bTestName) {
            long lDiff = -1;
            double dPct = -1.0;
            String sFaster = null;
            if(l_aDuration > l_bDuration) {
                lDiff = l_aDuration - l_bDuration;
                dPct = 100.00 - (l_bDuration * 100.0 / l_aDuration + 0.5);
                sFaster = "B";
            }
            else {
                lDiff = l_bDuration - l_aDuration;
                dPct = 100.00 - (l_aDuration * 100.0 / l_bDuration + 0.5);
                sFaster = "A";
            }
            System.out.println(sFaster + " faster by " + nf.format(lDiff) + " nanoseconds (" + dPct + "% faster)");
            return  lDiff;
       }

       //Timer testing utilities...END

    }

  [1]: http://docs.oracle.com/javase/1.5.0/docs/guide/language/foreach.html
  [2]: http://docs.oracle.com/javase/1.5.0/docs/guide/language/index.html
  [3]: http://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html
  [4]: http://www.java-made-easy.com/variable-scope.html
  [5]: https://stackoverflow.com/questions/1879255/traditional-for-loop-vs-iterator-in-java
  [6]: https://stackoverflow.com/questions/22110482/uses-and-syntax-for-for-each-loop-in-java/22110517#22110517
  [7]: https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java

Edit Summary*

Cancel

7

This answer is now a blog post and was created from two related answers that I've written: here and here. It also includes a generically useful class for comparing the speed of two functions (at the bottom).

aliteralmind
– aliteralmind

2014-04-19 18:23:12 +00:00
Commented Apr 19, 2014 at 18:23
3

Just one minor comment here, you shouldn't categorically state that for(:) syntax is always better for accessing collections; if you are using an array list, the for (:) loop will be about 2 x slower than using for (int i = 0, len = arrayList.size(); i < len; i++). I think you mentioned that in the [link]( stackoverflow.com/questions/2113216/…) link anyway, but is important to highlight that...

Leo
– Leo

2014-09-26 11:25:04 +00:00
Commented Sep 26, 2014 at 11:25
2

It's important to compare apples-to-apples, here. The question was about for versus foreach. You are comparing indexed-access versus iterated access. It's important to point out that foreach is just syntactic sugar wrapping "iterator" traversal of the collection. There is no discernible difference between for and foreach when you are always using an iterator, so it's not fair to imply that foreach is better for performance. Technically speaking, it generates the same code as a regular for loop provided that you are still using an iterator in the for loop.

Christopher Schultz
– Christopher Schultz

2019-10-18 20:35:59 +00:00
Commented Oct 18, 2019 at 20:35
2

To me saying that foreach is more performant when going through Collection is terribly misleading. If it is a linked list in a for loop using the get(i), you're not traversing once, you're traversing 1+2+..n times. Using iterable is to make sure to go through the Collection in the most optimal way without having to have to write extra code (ex : current = current.getChild()). Of course for ArrayList, you will be a bit faster using a for instead fo foreach because you don't need to construct the intermediary Iterator. A logical explanation is way better than benchmarks in this case for me

Walfrat
– Walfrat

2020-06-10 08:14:34 +00:00
Commented Jun 10, 2020 at 8:14
2

Since a for-each loop over a primitive array is compiled to the same bytecode as an index based for loop over the same array, any test that measures a significant performance difference between these two source code forms is obviously broken.

Holger
– Holger

2024-10-02 10:53:55 +00:00
Commented Oct 2, 2024 at 10:53

| Show 10 more comments

Correct minor typos or mistakes
Clarify meaning without changing it
Add related resources or links
Always respect the author’s intent
Don’t use edits to reply to the author

create code fences with backticks ` or tildes ~
```
like so
```
add language identifier to highlight code
```python
def function(foo):
print(foo)
```
put returns between paragraphs
for linebreak add 2 spaces at end
_italic_ or **bold**
indent code by 4 spaces
backtick escapes `like _so_`
quote by placing > at start of line
to make links (use https whenever possible)

<https://example.com>

[example](https://example.com)

<a href="https://example.com">example</a>

formatting help »
answering help »

Collectives™ on Stack Overflow

In detail, how does the 'for each' loop work in Java?

Answer*