// Insertion sort on smallest arrays
if (len < 7) {
for (int i=off; ioff && x[j-1]>x[j]; j–)
swap(x, j, j-1);
return;
}

// Choose a partition element, v
int m = off + (len >> 1); // Small arrays, middle element
if (len > 7) {
int l = off;
int n = off + len – 1;
if (len > 40) { // Big arrays, pseudomedian of 9
int s = len/8;
l = med3(x, l, l+s, l+2*s);
m = med3(x, m-s, m, m+s);
n = med3(x, n-2*s, n-s, n);
}
m = med3(x, l, m, n); // Mid-size, med of 3
}
int v = x[m];

// Establish Invariant: v* (v)* v*
int a = off, b = a, c = off + len – 1, d = c;
while(true) {
while (b <= c && x[b] = b && x[c] >= v) {
if (x[c] == v)
swap(x, c, d–);
c–;
}
if (b > c)
break;
swap(x, b++, c–);
}

// Swap partition elements back to middle
int s, n = off + len;
s = Math.min(a-off, b-a ); vecswap(x, off, b-s, s);
s = Math.min(d-c, n-d-1); vecswap(x, b, n-s, s);

// Recursively sort non-partition-elements
if ((s = b-a) > 1)
sort1(x, off, s);
if ((s = d-c) > 1)
sort1(x, n-s, s);
}

Not in Java, but in Adobe Flash, ironically.

http://blog.inspirit.ru/?p=271

For example, it’s not possible for an array to have a subscript that is beyond the bounds of the array. For example, you can’t have a 100 element array and then reference cell 105. Java throws an error.

This simple range checking functionality on every single instance of referencing an array causes a noticeable amount of overhead. Imagine putting an “if” check before every array subscript usage. I count 24 array subscripts in the PartialFlashSort algorithm alone. That’s 24 extra checks your code performs that the in-built .sort() routine can ignore.

Also, the inbuilt .sort() algorithm uses a “tuned quicksort” which performs significantly better than the standard quicksort on several troublesome data sets. Trying to beat a quicksort is a challenge in itself. If you add to that the additional overhead that the Java language adds, there’s no chance that any Java-based sorting algorithm can compete with the internal Java .sort() routine.