FULL PRODUCT VERSION :
java version "1.5.0_05"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_05-b05)
Java HotSpot(TM) Client VM (build 1.5.0_05-b05, mixed mode)

FULL OPERATING SYSTEM VERSION :
SunOS s0046mqa 5.7 Generic_106541-15 sun4us sparc FJSV,GPUS

A DESCRIPTION OF THE PROBLEM :
Summing up the elements of an int[] array using interfaces
for both the Iterator and the int wrapper Object takes 10
times(!) longer than using the concrete classes (on Solaris
7/SPARC, on Linux/Intel 2.3x, on WindowsNT 2.5x).

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
for a in 0 1 2 3 4 5 6
do
  java -server SlowInterface 1000000 20 20 $a
done


ACTUAL BEHAVIOR :
Linux on Pentium 4 mobile, 1.6 GHz, -server VM:
0: 215ms
1: 1715ms
2: 983ms
3: 1004ms
4: 264ms
5: 311ms
6: 160ms

Windows XP on Pentium 4, 2.4 GHz, 1Gb RAM, -server VM:
0: 94ms
1: 609ms
2: 594ms
3: 594ms
4: 188ms
5: 203ms
6: 78ms

This bug can be reproduced always.

---------- BEGIN SOURCE ----------
import java.util.*;

public class SlowInterface {
    //----------------------------------------------------------------------
    // int wrapper
    //----------------------------------------------------------------------
    private interface intReadRef {
int get ();
    }

    private interface intWriteRef {
void set (int value);
    }

    private interface intRef extends intReadRef, intWriteRef { }

    private static final class MutableInt implements intRef {
private int value;
public MutableInt (int value) { this.value = value; }
public MutableInt () { }
public int get () { return value; }
public void set (int value) { this.value = value; }
    }

    //----------------------------------------------------------------------
    // int[] iterators
    //----------------------------------------------------------------------
    private static abstract class IntArrayIterator implements Iterator {
protected final int[] a;
protected final int length;
protected int i;
protected int lastI = -1;
protected IntArrayIterator (int[] a, int i) { this.a = a; this.i = i;
length = a.length; }
public IntArrayIterator (int[] a) { this (a, 0); }
public final boolean hasNext () { return length > i; }
public final Object next () {
try {
return getUnchecked (lastI = i++);
} catch (ArrayIndexOutOfBoundsException e) {
throw new NoSuchElementException ("index: " + (lastI = --i)
+ ", length: " + length);
}
}
public final void remove () { throw new UnsupportedOperationException
(); }
protected abstract Object getUnchecked (int i);
    }

    private static final class MutableIterator extends IntArrayIterator {
private final MutableInt result = new MutableInt ();
public MutableIterator (int[] a) { super (a); }
protected Object getUnchecked (int i) { result.set (a [i]); return
result; }
    }

    //----------------------------------------------------------------------
    private static final long run (int alg, int[] a, long expectedSum, int n) {
long start = System.currentTimeMillis ();
for (int r = 0; r < n; ++r) {
long s = 0;

switch (alg) {
case 0: {
for (int i = 0; i < a.length; ++i) {
s += a [i];
}
} break;

case 1: {
for (Iterator i = new MutableIterator (a); i.hasNext (); ) {
s += ((intReadRef)i.next ()).get ();
}
} break;

case 2: {
for (Iterator i = new MutableIterator (a); i.hasNext (); ) {
s += ((intRef)i.next ()).get ();
}
} break;

case 3: {
for (Iterator i = new MutableIterator (a); i.hasNext (); ) {
s += ((MutableInt)i.next ()).get ();
}
} break;

case 4: {
for (MutableIterator i = new MutableIterator (a); i.hasNext
(); ) {
s += ((intReadRef)i.next ()).get ();
}
} break;

case 5: {
for (MutableIterator i = new MutableIterator (a); i.hasNext
(); ) {
s += ((intRef)i.next ()).get ();
}
} break;

case 6: {
for (MutableIterator i = new MutableIterator (a); i.hasNext
(); ) {
s += ((MutableInt)i.next ()).get ();
}
} break;

}

if (s != expectedSum) {
throw new IllegalStateException ("wrong sum (expected: " +
expectedSum + "; actual: " + s + ")");
}
}
return System.currentTimeMillis () - start;
    }

    public static void main (String[] args) {
int length = Integer.parseInt (args [0]);
int warmup = Integer.parseInt (args [1]);
int measure = Integer.parseInt (args [2]);
int alg = Integer.parseInt (args [3]);
int[] a = new int [length];
long expectedSum = (length / 2L) * (length + 1L);

// fill
for (int i = 0; i < length; ++i) {
a [ i] = i + 1;
}

run (alg, a, expectedSum, warmup);
System.out.println (alg + ": " + run (alg, a, expectedSum, warmup)
+ "ms");
    }
}

---------- END SOURCE ----------

CUSTOMER WORKAROUND :
Cast down to the concrete classes (not possible if concrete
classes are private inner classes).