Arrays.sort(Object[] a)源码分析

前言

Arrays.sort(Object[] a）是Arrays的一个非常重要的一个静态方法，可以对数组的进行排序，前提是数组中的元素必须实现了Comparable接口。所用的排序方法为归并排序法；作为集合排序的核心，非常重要。

归并排序

归并排序的一个主要的优点：稳定，即不需要交换相同的元素。

举例：假设有一个已经按照姓名排列的员工列表。现在，按照工资再按照工资排序。如果两个员工的工资相等会发生什么样的情况呢？如果采用稳定的排序算法，将会保留按名字排序的顺序。换句话说，排序的结果将会产生这样一个列表，首先对按照工资排序，工资相同者再按照名字排序。

源码分析

源码一（sort(Object[] a)）

static final class LegacyMergeSort {
        private static final boolean userRequested =
            java.security.AccessController.doPrivileged(
                new sun.security.action.GetBooleanAction(
                    "java.util.Arrays.useLegacyMergeSort")).booleanValue();
    }

public static void sort(Object[] a) {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a);
        else
            ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
    }

    /** To be removed in a future release. */
    private static void legacyMergeSort(Object[] a) {
        Object[] aux = a.clone();`在这里插入代码片`
        mergeSort(aux, a, 0, a.length, 0);
    }

分析
从以上代码看出sort方法有两个分支

• legacyMergeSort(a)
• ComparableTimSort.sort(a, 0, a.length, null, 0, 0)

当程序员System.setProperty("java.util.Arrays.useLegacyMergeSort", "true");时，LegacyMergeSort.userRequested的结果为true，反之为false。这个属性作为分支的依据，当属性值为true时，将会采用legacyMergeSort(a)方法对数组进行排序，反之采用ComparableTimSort.sort(a, 0, a.length, null, 0, 0)，由注释/** To be removed in a future release. */可以看到第一个排序算法在将来的版本会被抛弃。

源码二（ legacyMergeSort(a)）

在默认的情况下，mergeSort方法已经被弃用,但是其中的算法仍然值得我们去学习，模仿，当然能够创新就更好啦。

 private static final int INSERTIONSORT_THRESHOLD = 7;

    @SuppressWarnings({"unchecked", "rawtypes"})
    private static void mergeSort(Object[] src,
                                  Object[] dest,
                                  int low,
                                  int high,
                                  int off) {
        int length = high - low;

        // Insertion sort on smallest arrays
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low &&
                         ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

        // Recursively sort halves of dest into src
        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off);
        mergeSort(dest, src, mid, high, -off);

        // If list is already sorted, just copy from src to dest.  This is an
        // optimization that results in faster sorts for nearly ordered lists.
        if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

        // Merge sorted halves (now in src) into dest
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }

    /**
     * Swaps x[a] with x[b].
     */
    private static void swap(Object[] x, int a, int b) {
        Object t = x[a];
        x[a] = x[b];
        x[b] = t;
    }

片段一

private static final int INSERTIONSORT_THRESHOLD = 7;

    @SuppressWarnings({"unchecked", "rawtypes"})
    private static void mergeSort(Object[] src,
                                  Object[] dest,
                                  int low,
                                  int high,
                                  int off) {
        int length = high - low;

        // Insertion sort on smallest arrays
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low &&
                         ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

  /**
     * Swaps x[a] with x[b].
     */
    private static void swap(Object[] x, int a, int b) {
        Object t = x[a];
        x[a] = x[b];
        x[b] = t;
    }

INSERTIONSORT_THRESHOLD是一个阈值默认值为7，当数组的长度小于阈值时，将对整个数组从左到右排序。值得关注的是，可以看到只有当comparaTo方法返回正数才能对数组相邻两个元素调换位置，那么当我们在实现compareTo方法时，当相邻两元素不符合顺序（程序员自己定义）时，返回正数（不一定为1），这时这2个元素将会交换位置，当然，在默认的情况下，mergeSort方法已经被弃用。

片段二

 // Recursively sort halves of dest into src
        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off);
        mergeSort(dest, src, mid, high, -off);

当阈值大于7时，数组将分为2半再进行递归排序，如果其中一半长度仍然大于7，那么还会再分，直到子数组长度不再大于7，为什么要分为2半呢？考虑最糟糕的情况，数组为反序，那么元素交换位置的次数为$$n(n-1)/2$$单n大于1时，n越大该函数的导数越大，所以分为2半就可以减少次数。这里要特别注意， mergeSort(dest, src, low, mid, -off)，是对src的一半进行排序，src是dest的克隆，至于为什么做，请往下看。

片段三

 	// If list is already sorted, just copy from src to dest.  This is an
     // optimization that results in faster sorts for nearly ordered lists.
        if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

当排序好的两段数组刚好符合排序规则，即前一半数组最后一个元素与后一半数组第一个元素符合所定义的排序规则时，直接将src数组中元素复制到dest数组。
片段四

 // Merge sorted halves (now in src) into dest
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }

通常来说，一半很少出现前后两段数组排序好后，刚好符合排序规则。那么便要执行以上代码，复制n次就可以对前后两段代码完成排序。这也是对dest数组克隆出src的原因。如果按照传统方法对dest分两段再排序，那么对前后两段数组排序时，每一次交换位置必须执行一次swap方法，比直接复制耗时多。