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

The for-each loop, added in Java 5 (also called the "enhanced for loop"), is equivalent to using a java.util.Iterator--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 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 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):

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000Test A: 358,597,622 nanosecondsTest B: 269,167,681 nanosecondsB faster by 89,429,941 nanoseconds (24.438799231635727% faster)[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000Test A: 377,461,823 nanosecondsTest B: 278,694,271 nanosecondsB faster by 98,767,552 nanoseconds (25.666236154695838% faster)[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000Test A: 288,953,495 nanosecondsTest B: 207,050,523 nanosecondsB faster by 81,902,972 nanoseconds (27.844689860906513% faster)[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000Test A: 375,373,765 nanosecondsTest B: 283,813,875 nanosecondsB faster by 91,559,890 nanoseconds (23.891659337194227% faster)[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000Test A: 375,790,818 nanosecondsTest B: 220,770,915 nanosecondsB faster by 155,019,903 nanoseconds (40.75164734599769% faster)[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000Test A: 326,373,762 nanosecondsTest B: 202,555,566 nanosecondsB 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.):

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000Test A: 3,429,929,976 nanosecondsTest B: 5,262,782,488 nanosecondsA faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000Test A: 2,907,391,427 nanosecondsTest B: 3,957,718,459 nanosecondsA faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000Test A: 2,566,004,688 nanosecondsTest B: 4,221,746,521 nanosecondsA faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000Test A: 2,770,945,276 nanosecondsTest B: 3,829,077,158 nanosecondsA faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000Test A: 3,467,474,055 nanosecondsTest B: 5,183,149,104 nanosecondsA faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)[C:\java_code\]java TimeIteratorVsIndexIntList 1000000Test A: 3,439,983,933 nanosecondsTest B: 3,509,530,312 nanosecondsA faster by 69,546,379 nanoseconds (1.4816434912159906% faster)[C:\java_code\]java TimeIteratorVsIndexIntList 1000000Test A: 3,451,101,466 nanosecondsTest B: 5,057,979,210 nanosecondsA 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

• Should I use an Iterator or a forloop to iterate?

Some more information: 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 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}