Why is the ArrayList.iterator() so slow

Question

Take a look at the code below. I believe its correct. If so, I can get 3x the performance doing a classic for loop when iterating the list.
public static void main(String[] args)
          List<Double> theList = new ArrayList<Double>(LIST_LENGTH);
          //Only run last test with Linked List
          //List<Integer> theList = new LinkedList<Integer>();
          Random rand = new Random();
          System.out.print("Populating list with " + LIST_LENGTH + " items.");
          for (int i = 0; i < LIST_LENGTH; i++)
               theList.add(rand.nextDouble());
          System.out.println("Done!");
          //new Zebra(theList);
          System.out.println("Classic For Loop");
          double t1 = 0;
          long start = System.currentTimeMillis();
          for (int i = 0; i < LIST_LENGTH; i++)
               t1 += theList.get(i);
          long stop = System.currentTimeMillis();
          System.out.println("Total1: "  + t1 + " Time: "+  + (stop - start));
          System.out.println("New For Each Loop");
          double t2 = 0;
          long start2 = System.currentTimeMillis();
          for (double f : theList)
               t2 += f;
          long stop2 = System.currentTimeMillis();
          System.out.println("Total2: " + t2 + " Time: "+ (stop2 - start2));
          System.out.println("Iterator based loop");
          double t3 = 0;
          long start3 = System.currentTimeMillis();
          for (Iterator<Double> it = theList.listIterator(); it.hasNext();)
               t3 += it.next();
          long stop3 = System.currentTimeMillis();
          System.out.println("Total3: " + t3 + " Time: "+ (stop3 - start3));
     }Here is a print screen of a run. These results are typical. It does not matter which order I run the test.
Populating list with 20000001 items.Done!
Classic For Loop
Total1: 9999145.376459487 Time: 375
New For Each Loop
Total2: 9999145.376459487 Time: 1079
Iterator based loop
Total3: 9999145.376459487 Time: 1063Anyone running this will need to get their -Xmx parameter up fairly high.

Answer 1

I expect that's the case. There are times though, like in this sample, when there is no chance the list will be modified by another thread. I guess this is just a lesson "knowing your language." I discovered this when testing a multiple thread sumation. For the curious I have posted the rest of the class below. It would be interesting to see the results on an Core i7 processor.
One thing this does show is that "multi-threaded" is not necessairly the best way to do things. I have to have a very large collection before the "Divide and conquor" approach shows any benefit. Test relatively similar performance until I get to a collection of 2,000,000 or more objects.
This test also shows how inaccurate even dobule percision floating point math can be. If I change the items in the lists to ints the numbers will all match. There cases when using doubles will match too. Ex: Instead of using random numbers I just use "1". In this case using floats will be different but using doubles will give the right answer.
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.Set;
public class Zebra
     private final Set<xThread> runningThreads = new HashSet<xThread>();
     private float total = 0;
     private static final int LIST_LENGTH = 50000000;
     private static final int NUM_THREADS = Runtime.getRuntime().availableProcessors();
     public Zebra(final List<Double> theList)
          final int LIST_LENGTH = theList.size();
          final int paddingNeeded = (LIST_LENGTH % NUM_THREADS) > 0 ?
                                       NUM_THREADS - (LIST_LENGTH % NUM_THREADS) : 0;
          final int effectiveLength = LIST_LENGTH + paddingNeeded;
          System.out.println("Adding padding " + paddingNeeded);
          for (int i = 0; i < paddingNeeded; i++)
               theList.add(0d);
          // Split job into threads
          System.out.println("Divide and Conquor (note this test is counting overhead of setting up threads)");
          long start = System.currentTimeMillis();
          synchronized (this)
               for (int i = 0; i < NUM_THREADS; i++)
                    xThread x = new Zebra.xThread(theList,
                                                         (effectiveLength / NUM_THREADS) * i,
                                                         (effectiveLength / NUM_THREADS) * (i + 1), this);
                    runningThreads.add(x);
                    x.start();
               while (runningThreads.size() > 0)
                    try
                         wait();
                    catch (InterruptedException e)
                         e.printStackTrace();
          if (paddingNeeded > 0)
               for (int i = 0; i < paddingNeeded; i++)
                    theList.remove(theList.size() - 1);
          long stop = System.currentTimeMillis();
          System.out.println("Total: " + total + " Time: " + (stop - start));
     private void threadDone(xThread x)
          synchronized (this)
               runningThreads.remove(x);
               notifyAll();
               total += x.getTotal();
     private class xThread extends Thread
          private final List<Double> list;
          private final int startIndex, endIndex;
          private final Zebra backRef;
          private double total = 0;
          public xThread(List<Double> list, int startIndex, int endIndex,
                    Zebra backRef)
               this.list = list;
               this.startIndex = startIndex;
               this.endIndex = endIndex;
               this.backRef = backRef;
          public double getTotal()
               return total;
          public void run()
               for (int i = startIndex; i < endIndex; i++)
                    total += list.get(i);
               backRef.threadDone(this);
     public static void main(String[] args)
          List<Double> theList = new ArrayList<Double>(LIST_LENGTH);
          //Only run last test with Linked List
          //List<Integer> theList = new LinkedList<Integer>();
          Random rand = new Random();
          System.out.print("Populating list with " + LIST_LENGTH + " items.");
          for (int i = 0; i < LIST_LENGTH; i++)
               theList.add(rand.nextDouble());
          System.out.println("Done!");
          new Zebra(theList);
          System.out.println("Classic For Loop");
          double t1 = 0;
          long start = System.currentTimeMillis();
          for (int i = 0; i < LIST_LENGTH; i++)
               t1 += theList.get(i);
          long stop = System.currentTimeMillis();
          System.out.println("Total1: "  + t1 + " Time: "+  + (stop - start));
          System.out.println("New For Each Loop");
          double t2 = 0;
          long start2 = System.currentTimeMillis();
          for (double f : theList)
               t2 += f;
          long stop2 = System.currentTimeMillis();
          System.out.println("Total2: " + t2 + " Time: "+ (stop2 - start2));
          System.out.println("Iterator based loop");
          double t3 = 0;
          long start3 = System.currentTimeMillis();
          for (Iterator<Double> it = theList.listIterator(); it.hasNext();)
               t3 += it.next();
          long stop3 = System.currentTimeMillis();
          System.out.println("Total3: " + t3 + " Time: "+ (stop3 - start3));
}Results:
Populating list with 50000000 items.Done!
Adding padding 0
Divide and Conquor (note this test is counting overhead of setting up threads)
Total: 2.499794E7 Time: 656
Classic For Loop
Total1: 2.499794097321981E7 Time: 954
New For Each Loop
Total2: 2.499794097321981E7 Time: 3080
Iterator based loop
Total3: 2.499794097321981E7 Time: 2658