Collections 的sort源碼閱讀（對比1.7以前和1.7以後sort作了哪些優化）

jdk1.7 和 jdk1.8作對比閱讀

jdk1.7

public static <T extends Comparable<? super T>> void sort(List<T> var0) {
    Object[] var1 = var0.toArray();
    //對var1排序後
    Arrays.sort(var1);
    ListIterator var2 = var0.listIterator();
    //從新覆蓋到 var0
    for(int var3 = 0; var3 < var1.length; ++var3) {
        var2.next();
        var2.set((Comparable)var1[var3]);
    }

}

public static <T> void sort(List<T> var0, Comparator<? super T> var1) {
    Object[] var2 = var0.toArray();
    Arrays.sort(var2, var1);
    ListIterator var3 = var0.listIterator();

    for(int var4 = 0; var4 < var2.length; ++var4) {
        var3.next();
        var3.set(var2[var4]);
    }

}

jdk1.8

public static <T extends Comparable<? super T>> void sort(List<T> list) {
    list.sort(null);
}

default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    Arrays.sort(a, (Comparator) c);
    ListIterator<E> i = this.listIterator();
    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}

最終都是走到了 Arrays.sort方法

public static <T> void sort(T[] a, Comparator<? super T> c) {
    if (c == null) {
        sort(a);
    } else {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, c);
        else
            TimSort.sort(a, 0, a.length, c, null, 0, 0);
    }
}

這裏注意 LegacyMergeSort.userRequested  ，讀取的java.util.Arrays.useLegacyMergeSort 用來兼容歷史排序方法，好比1.7版本的jdk想使用1.6的排序方法，就須要配置這個參數  java.util.Arrays.useLegacyMergeSort=true

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

接下來先看一下1.7之前使用的哪一種排序辦法

private static void mergeSort(Object[] src,
                              Object[] dest,
                              int low,
                              int high,
                              int off) {
    int length = high - low;

    // 這裏是一個優化點，若是是一個比較小的數組 直接使用插入排序
    if (length < INSERTIONSORT_THRESHOLD) {//這裏默認是 7數組長度小於7
        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;//二進制右移一位至關於除以2
    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) {//若是兩部分分別排序後，左側的最大 小於右側最小 說明總體 src已經有序 直接複製到 dest
        System.arraycopy(src, low, dest, destLow, length);
        return;
    }

    // 
    for(int i = destLow, p = low, q = mid; i < destHigh; i++) {//分別遍歷左側 和右側 合併到dest，須要考慮到某一個先遍歷到頭後的情景 q>=high 和 p<mid
        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;
}

綜合下來就是 歸併+插入排序完成的。

接下來看1.7 和1.8的實現，他們的變化不變，這裏就只貼1.8了

根據是否有 Comparator 參數分別爲，帶Comparator參數

static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
                     T[] work, int workBase, int workLen) {
    assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;

    int nRemaining  = hi - lo;
    if (nRemaining < 2)//長度小於2 直接返回
        return;  // Arrays of size 0 and 1 are always sorted

    // If array is small, do a "mini-TimSort" with no merges
    if (nRemaining < MIN_MERGE) {//長度小於32 直接返回
        int initRunLen = countRunAndMakeAscending(a, lo, hi, c);//獲取有序段，即lo 到幾是有序的（若是是從大到小有序的話，會對這一小段進行反轉）
        //執行到這裏，0，到initRunLen 是有序的了
        binarySort(a, lo, hi, lo + initRunLen, c);//二分插入排序，就是把initRunLen位置後面的數據，經過二分搜索定位的方式插入到前面有序段落裏面
        // 這裏想吐槽一下  和 1.7以前的直接對小數組直接進行插入排序 感受複雜了好多，不過確實複雜度變小了 從O(n^2) 變爲了 O(nlogn)
        return;
    }

    /**
     * March over the array once, left to right, finding natural runs,
     * extending short natural runs to minRun elements, and merging runs
     * to maintain stack invariant.
     */
    TimSort<T> ts = new TimSort<>(a, c, work, workBase, workLen);
    int minRun = minRunLength(nRemaining);//獲取有序run塊的最小長度
    do {
        // Identify next run
        int runLen = countRunAndMakeAscending(a, lo, hi, c);//獲取有序遞增塊的長度

        // If run is short, extend to min(minRun, nRemaining)
        if (runLen < minRun) {//若是長度太短，進行優化補充
            int force = nRemaining <= minRun ? nRemaining : minRun;
            binarySort(a, lo, lo + force, lo + runLen, c);
            runLen = force;
        }

        // Push run onto pending-run stack, and maybe merge
        ts.pushRun(lo, runLen);
        ts.mergeCollapse();//兩個有序塊進行合併

        // Advance to find next run
        lo += runLen;
        nRemaining -= runLen;
    } while (nRemaining != 0);

    // Merge all remaining runs to complete sort
    assert lo == hi;
    ts.mergeForceCollapse();
    assert ts.stackSize == 1;
}

//用於獲取一個遞增連續區域長度
private static int countRunAndMakeAscending(Object[] a, int lo, int hi) {
    assert lo < hi;
    int runHi = lo + 1;
    if (runHi == hi)
        return 1;

    // Find end of run, and reverse range if descending
    if (((Comparable) a[runHi++]).compareTo(a[lo]) < 0) { // Descending
        while (runHi < hi && ((Comparable) a[runHi]).compareTo(a[runHi - 1]) < 0)
            runHi++;
        reverseRange(a, lo, runHi);
    } else {                              // Ascending
        while (runHi < hi && ((Comparable) a[runHi]).compareTo(a[runHi - 1]) >= 0)
            runHi++;
    }

    return runHi - lo;
}

//二分插入排序
private static void binarySort(Object[] a, int lo, int hi, int start) {
    assert lo <= start && start <= hi;
    if (start == lo)
        start++;
    for ( ; start < hi; start++) {
        Comparable pivot = (Comparable) a[start];

        // Set left (and right) to the index where a[start] (pivot) belongs
        int left = lo;
        int right = start;
        assert left <= right;
        /*
         * Invariants:
         *   pivot >= all in [lo, left).
         *   pivot <  all in [right, start).
         */
        while (left < right) {
            int mid = (left + right) >>> 1;
            if (pivot.compareTo(a[mid]) < 0)
                right = mid;
            else
                left = mid + 1;
        }
        assert left == right;

        /*
         * The invariants still hold: pivot >= all in [lo, left) and
         * pivot < all in [left, start), so pivot belongs at left.  Note
         * that if there are elements equal to pivot, left points to the
         * first slot after them -- that's why this sort is stable.
         * Slide elements over to make room for pivot.
         */
        int n = start - left;  // The number of elements to move
        // Switch is just an optimization for arraycopy in default case
        switch (n) {
            case 2:  a[left + 2] = a[left + 1];
            case 1:  a[left + 1] = a[left];
                     break;
            default: System.arraycopy(a, left, a, left + 1, n);
        }
        a[left] = pivot;
    }
}

接下來着重看一下最後的排序步驟

private void pushRun(int runBase, int runLen) {
    this.runBase[stackSize] = runBase;
    this.runLen[stackSize] = runLen;
    stackSize++;
}

private void mergeCollapse() {
    while (stackSize > 1) {
        int n = stackSize - 2;
        if (n > 0 && runLen[n-1] <= runLen[n] + runLen[n+1]) {
            if (runLen[n - 1] < runLen[n + 1])
                n--;
            mergeAt(n);
        } else if (runLen[n] <= runLen[n + 1]) {
            mergeAt(n);
        } else {
            break; // Invariant is established
        }
    }
}

總結，1.7以前的排序更易懂，插入+歸併，數組長度低於7直接插入排序，

1.7開始使用TimSort+二分插入，數組長度小於32，直接二分插入排序

TimSort的平均時間複雜度和最壞時間複雜度和歸併同樣O(nlogn)，可是其最好狀況能達到O(n)

有理解錯誤的地方歡迎你們指出，後面有時間會看一下 java9的 sort實現方式作了哪些優化