Will java programs become slower with generics?

Question

This is not a question, more lika general discussion. I'd like to know what you think.
I fear that the average java developer will become accustom to the new features of java and write inefficient code. I have included a sample program that shows new code vs. old code. Altough the new code is esier to read, it's also alot slower.
For instance the foreach instruction is using an iterator which is created and then iterated. When the loop exits the Iterator is garanage collected. Better performance would be achieved if there was a "Getable" interface of some sort was implemented and that the foreach simply asked the collections class for the next object in line. Perhapps if the ArrayList cached it's Iterator objects, somehow. (I'm not suggesting any of the solutions above. I'm just trying to make a point.)
Also regarding generics and enumerations it's easy to see how they will slow down the application. It gets even scarier when you consider that important foundation classes are updated with these new features. A small change in some AWT class may have unforeseen repercussions throughout all gui applications.
Gafter, if you read this, is there any tests made to see if this is true. Is performance affected by the new features? Will old style code be replace by new style code in the foundation classes (awt/swing/.../... etc.).
ArrayList<String> ss = new ArrayList<String>();
for (int i = 0; i < 100; i++) ss.add("hello");
// "new" java ... completes in 6.43 seconds
long t1 = System.nanoTime();
for (int i = 0; i < 1000000; i++)
     for (String s : ss)
System.out.println(System.nanoTime()-t1);
// "old" java ... completes in 2.58 seconds
long t2 = System.nanoTime();
for (int i = 0; i < 1000000; i++)
     for (int j = 0, size = ss.size(); j < size; j++)
          String s = ss.get(j);
System.out.println(System.nanoTime()-t2);

Answer 1

Adapting Neal's example for JDK 1.4:
    private static final String[] strArray = new String[0];   
    private static void withToArray() {
        List ss = new ArrayList();
        for (int i = 0; i < 100; i++) ss.add("hello");
        long t1 = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++)
            String[] ssArray =  (String[]) ss.toArray(strArray);
            for (int j=0;  j < ssArray.length; j++) {
                String s = ssArray[j];               
        System.out.println(System.currentTimeMillis()-t1);
    private static final String[] strArray100 = new String[100];   
    private static void withToArrayAndCheatingOnLength() {
        List ss = new ArrayList();
        for (int i = 0; i < 100; i++) ss.add("hello");
        long t1 = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++)
            String[] ssArray =  (String[]) ss.toArray(strArray100);
            for (int j=0;  j < ssArray.length; j++) {
                String s = ssArray[j];               
        System.out.println(System.currentTimeMillis()-t1);
    private static void withToArrayAndCheatingOnLengthLocalVar() {
        List ss = new ArrayList();
        for (int i = 0; i < 100; i++) ss.add("hello");
        final String[] localStrArray100 = new String[100];           
        long t1 = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++)
            String[] ssArray =  (String[]) ss.toArray(localStrArray100);
            for (int j=0;  j < ssArray.length; j++) {
                String s = ssArray[j];               
        System.out.println(System.currentTimeMillis()-t1);
    } Allocating the string[] every time: 5812
Allocating the correctly sized string[] once, as a private final static: 2953
Allocating the correctly sized string[] once, as a final local var: 3141
Interesting that the private final static is 90ms faster than the local variable, fairly consistently.
What's interesting about that though, is that we're not iterating strArray100, we're iterating over ssArray, so its not clear why it should make a difference. If I modify things a little more:
    private static void withToArrayAndLoopOptimization() {
        List ss = new ArrayList();
        for (int i = 0; i < 100; i++) ss.add("hello");
        long t1 = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++)
            String[] ssArray =  (String[]) ss.toArray(strArray100);
            final int length = ssArray.length;              
            for (int j=0;  j < length; j++) {
                String s = ssArray[j];               
        System.out.println(System.currentTimeMillis()-t1);
    private static void withToArrayAndLoopOptimizationLocalVar() {
        List ss = new ArrayList();
        for (int i = 0; i < 100; i++) ss.add("hello");
        final String[] localStrArray100 = new String[100];           
        long t1 = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++)
            String[] ssArray =  (String[]) ss.toArray(localStrArray100);
            final int length = ssArray.length;  
            for (int j=0;  j < length; j++) {
                String s = ssArray[j];               
        System.out.println(System.currentTimeMillis()-t1);
    }  With private static final and loop optimization: 2937
With local variable and loop optimization: 2922
Now the different has disappeared: in fact, the numbers are exactly the same on many runs. You have to make 'length' final to get the best speed.
I guess I'm disappointed that in 2004, Java 1.4 javac & Hotspot combined still cannot spot the simplest loop optimization in the book.... always assuming that's actually causing the preformance difference. My gut is telling me its something else causing the difference because all of the inner loops are iterating over ssArray, not strArray100 (wherever that happends to be declared).
Someone care to run Neal's example on 1.5 and see if they've managed to optimize further under the covers?