Ускорить алгоритм сортировки

    public static void sort(final Model[] src, final Model[] dest,
                            final int low, final int high, final int parity) {
        final int length = high - low;
 
        // на маленьких массивах сортировка вставками
        if (length < 40 && parity == 0) {
            for (int i = low + 1; i < high; i++) {
                for (int j = i; j > low && dest[j - 1].value > dest[j].value; j--) {
                    final Model t = dest[j];
                    dest[j] = dest[j - 1];
                    dest[j - 1] = t;
                }
            }
            return;
        }
 
        // Рекурсивная сортировка из dest в src
        final int mid = (low + high) >>> 1;
        sort(dest, src, low, mid, 1 - parity);
        sort(dest, src, mid, high, 1 - parity);
 
        // Оптимизация для почти отсортированных массивов
        if (src[mid - 1].value <= src[mid].value) {
            System.arraycopy(src, low, dest, low, length);
            return;
        }
 
        // Мёрж отсортированных половинок из src в dest
        for (int i = low, p = low, q = mid; i < high; i++) {
            if (q >= high || p < mid && src[p].value <= src[q].value) {
                dest[i] = src[p++];
            } else {
                dest[i] = src[q++];
            }
        }
    }

import java.util.Arrays;
import java.util.Random;
 
public class Helper {
 
    public static void main(String[] args) {
        Integer[] aIntArray = getRundIntegerArray(22);
        System.out.println(Arrays.toString(aIntArray));
        QuickSort.sort(aIntArray,0, aIntArray.length - 1);
        System.out.println(Arrays.toString(aIntArray));
 
        String[] aStrArray = getRundStrArray(22);
        System.out.println(Arrays.toString(aStrArray));
        QuickSort.sort(aStrArray,0, aStrArray.length - 1);
        System.out.println(Arrays.toString(aStrArray));
    }
 
    private static Integer[] getRundIntegerArray(int count){
        Integer[] ret = new Integer[count];
        Random rgen = new Random(System.currentTimeMillis());
        for (int i = 0; i < ret.length; i++) {
            ret[i] = rgen.nextInt(100);
        }
        return ret;
    }
 
    private static String[] getRundStrArray(int count){
        String[] ret = new String[count];
        Random rgen = new Random(System.currentTimeMillis());
        for (int i = 0; i < ret.length; i++) {
            ret[i] = "s" + rgen.nextInt(100);
        }
        return ret;
    }
}
class QuickSort {
    private static Random rgen = new Random(System.currentTimeMillis());
 
    public static <T extends Comparable<T>> void sort(T[] v, int left, int right) {
        int i, last;
        if (left >= right )
            return;
        swap(v, left, rand(left, right));
        last = left; // в v[left]
        for (i = left+1; i <= right; i++) 
            if (v[i].compareTo(v[left]) < 0)
                swap(v, ++last, i);
        swap(v, left, last);
        sort(v, left, last-1);
        sort(v, last+1, right);
    }
 
    private static int rand(int left, int right) {
        return left + Math.abs(rgen.nextInt())%(right-left+1);
    }
 
    private static <T> void swap(T[] v, int i, int j) {
        T temp;
        temp = v[i];
        v[i] = v[j];
        v[j] = temp;
    }
}