Java vs .NETTO-performance

Ich habe mich selbst sehr überrascht, nachdem ich schrieb dieses kleine code zu vergleichen .NET 4.5 und Java 8 Leistung in meinem Rechner:

class ArrayTest
{
    public int[][] jagged;

    public ArrayTest(int width, int height)
    {
        Height = height;
        Width = width;
        Random rng = new Random();
        jagged = new int[width][];
        for (int i = 0; i < height; i++)
        {
            jagged[i] = new int[width];
            for (int j = 0; j < jagged[i][j]; j++)
            {
                jagged[i][j] = rng.Next(2048);
            }
        }
    }
    public int this[int i, int j]
    {
        get
        {
            return jagged[i][j];
        }
        set
        {
            jagged[i][j] = value;
        }
    }

    public void DoMath(ArrayTest a)
    {
        for (int i = 0; i < Height; i++)
        {
            for (int j = 0; j < Width; j++)
            {
                this[i, j] *= a[i, j];
            }
        }
    }

    public int Height { get; private set; }

    public int Width { get; private set; }
}



class Program
{
    static void Main(string[] args)
    {
        Random rng = new Random();
        const int loop = 10;
        int width = 10000,
            height = 10000;

        ArrayTest a1 = new ArrayTest(width, height),
            a2 = new ArrayTest(width, height);


        Stopwatch sw = new Stopwatch();
        sw.Start();
        for (int i = 0; i < loop; i++)
        {
            a1.DoMath(a2);
        }
        sw.Stop();

        Console.WriteLine("Time taken: " + sw.ElapsedMilliseconds);

        Console.ReadKey();
    }
}

Hier ist die Java-version:

    public class ArrayTest {
    private int width, height;
    private int[][] array;

    public ArrayTest(int width, int height) {
        this.width = width;
        this.height = height;
        array = new int[height][width];
        Random rng = new Random();
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                array[i][j] = rng.nextInt(2048);
            }
        }
    }

    public int getWidth() {
        return width;
    }
    public void setWidth(int width) {
        this.width = width;
    }
    public int getHeight() {
        return height;
    }
    public void setHeight(int height) {
        this.height = height;
    }
    public int[][] getArray() {
        return array;
    }

    public void doMath(ArrayTest a) {
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                array[i][j] *= a.getArray()[i][j];
            }
        }
    }

}

public class Main {

    public static void main(String[] args) {
        //TODO Auto-generated method stub
        final int loops = 10;
        int width = 10000, height = 10000;
        ArrayTest a1 = new ArrayTest(width, height),
                a2 = new ArrayTest(width, height);

        long start, end;


        start = java.lang.System.currentTimeMillis();
        for (int i = 0; i < loops; i++) {
            a1.doMath(a2);
        }
        end = java.lang.System.currentTimeMillis();
        System.out.println("Elapsed time: " + (float)(end - start));
    }

}

In meinem computer, auf dem diese C# - code ist die Einnahme über 5200ms zu laufen, und die Java version ist die Einnahme über 2800ms(!!!).
Ich hatte eigentlich erwartet, dass die .NET-version würde schneller laufen (oder zumindest in der Nähe) als Java, aber wurde sehr überrascht, mit diesem Ergebnis.

Hinweis: ich lief die .NET-version im release-Modus, die außerhalb von Visual Studio.

Kann jemand erklären Sie dieses Ergebnis? Ist das wirklich richtig?
Wie könnte ich diese umschreiben von code, so dass die C#.NET version näher an der Java one in der Ausführungsgeschwindigkeit?

[Bearbeiten]

Gut, ich weiß, das ist nicht wirklich gültig, benchmarking oder ein fairer Vergleich, aber wie könnte ich diese umschreiben von code, so dass die C#.NET version näher an der Java one in der Ausführungsgeschwindigkeit?
Versucht in allen Formen (Manipulation der jagged-array direkt über eine get-Methode, etc), aber der test lief auch langsamer.

[edit 2]

Bearbeitet den test, so dass ich die Breite und height = 500, und loop = 5000.
Jetzt bekomme ich über 6300ms für .NET-version, und über 3700ms für Java-version. lief der test mehrere Male für jede version, natürlich.

[edit 3]

Schrieb gerade einen ähnlichen test mit Flachbild-arrays statt mit 2D-arrays, und dieses mal die .NET-version läuft genauso oder sogar schneller als Java. So ist es das?
C#.NET's jagged arrays sind nur langsamer als Java mehrdimensionale arrays?