Stephan Schwab's blog entry brought a recent benchmark done by BentUser to my attention. The benchmark claims that .NET 2.0 is significantly faster than Java. According to BentUser, Java took about 355 ms to sort 1,000 floating point numbers using a selection sort. That number immediately sent up a bunch of red flags in my mind. Yeah, I know a selection sort is pretty inefficient, but 355 ms to sort 1,000 numbers? That's a ridiculously long time. I began to think their tests were seriously flawed, so I decided to write up my own.

The results? A selection sort, sorting a 1,000 element floating point array, with Java 5 running the server VM on my Celeron M 1.2 Ghz laptop, took 9 ms--a far cry from the 355 ms they reported on their Pentium D 3.0 Ghz system with 2 Mb of cache. That seemed like a lot more reasonable number. They also ran the test with 100,000 elements, for which they reported that Java took 37 seconds to complete the sort. Yeah, I know that no one actually sorts a 100,000 element array in reality using a selection sort, but I decided to humor them anyway. I sent my class file to Matt to run on his system. Running it on an Athlon64 2.19 Ghz system running 32 bit Windows XP and a 32 bit JVM produced a time of 30 seconds--again less than the time they reported on a significantly faster system with significantly more onboard cache.

My conclusions? To start with, the conclusion that .NET is faster than Java is completely flawed to begin with since the only test they based that on was a selection sort with an unreasonably large data set. Simply put, no one sorts a 100,000 element floating point array using a selection sort. But to confound matters even worse, their tests were seriously flawed, which caused them to produce bogus numbers. My opinion is that their conclusion is totally unfounded.

Here's the link to this benchmark:

.NET vs. Java Shootout

public static void selectionSort(double[] numbers, int arraySize){
  long start = System.currentTimeMillis();
  int sizeSub1 = arraySize-1;
  for (int i=0;i<sizeSub1;i++){
    int largestIdx = i;
    for (int j=i+1; j < arraySize;j++){
      if (numbers[j] > numbers[largestIdx]){
        largestIdx = j;
      }
    }
    // do swap
    double temp = numbers[i];
    numbers[i] = numbers[largestIdx];
    numbers[largestIdx] = temp;
  }
  long stop = System.currentTimeMillis();
  System.out.println("TIME TAKEN " + (stop - start)+ "ms");
}

It appears that Microsoft .NET has not only caught up to Java in many ways, but it has surpassed it in terms of implementation efficiency.

This is not surprising since Microsoft continues to prosper while Sun appears to be in a slow decline as businesses move away from expensive, proprietary systems.

This is not to say that Java should be discarded completely, but we have a clear efficiency champion in .NET.