java-collections.sort異常Comparison method violates its general contract!

由於業務須要，本身的model實現了Comparable接口，在Service層使用Collections.sort()方法對model對象的list進行排序。

可是在運行的時候，卻報下面的異常。

java.lang.IllegalArgumentException: Comparison method violates its general contract!
    at java.util.ComparableTimSort.mergeHi(ComparableTimSort.java:866)
    at java.util.ComparableTimSort.mergeAt(ComparableTimSort.java:483)
    at java.util.ComparableTimSort.mergeCollapse(ComparableTimSort.java:404)
    at java.util.ComparableTimSort.sort(ComparableTimSort.java:213)
    at java.util.Arrays.sort(Arrays.java:1312)
    at java.util.Arrays.sort(Arrays.java:1506)
    at java.util.ArrayList.sort(ArrayList.java:1454)
    at java.util.Collections.sort(Collections.java:141)

通過搜索得知，在JDK7之後，實現Comparable接口後，要知足一下三個特性：

1） 自反性：x，y 的比較結果和 y，x 的比較結果相反。

2） 傳遞性：x>y,y>z,則 x>z。

3） 對稱性：x=y,則 x,z 比較結果和 y，z 比較結果相同。

而個人代碼中,由於有對象屬性爲null的判斷，因此有如下模式的代碼

if (this.xxx== null || o.xxx== null) {
    return 0;
}
int xxxFirst = this.xxx.compareTo(o.xxx);
if (xxxFirst != 0) {
    return xxxFirst;
}
......

這種是有不知足對稱性的結果的。

所以只能完善對象屬性爲null的判斷

if (this.xxx == null && o.xxx == null) {
    return 0;
}
if (this.xxx == null) {
    return 1;
}
if (o.xxx == null) {
    return -1;
}

這一點是JDK6和JDK7+以上不兼容的點。

能夠經過在代碼中，System.setProperty("java.util.Arrays.useLegacyMergeSort", "true");  或者設置JVM參數-Djava.util.Arrays.useLegacyMergeSort=true來兼容JDK6的代碼。

這是由於JDK在函數Arrays.sort中，使用了一個if判斷來決定使用什麼排序算法來對數組進行排序。

public static void sort(Object[] a, int fromIndex, int toIndex) {  
    if (LegacyMergeSort.userRequested)  
        legacyMergeSort(a, fromIndex, toIndex);  
    else  
        ComparableTimSort.sort(a, fromIndex, toIndex);

不設置就使用ComparableTimSort實現的TimSort算法來進行排序。

下面是JDK1.8.0_102中legacyMergeSort的主要代碼

/**
 * 已經將src數組複製了一份到dest數組
 * low和high是mergesort在數組中的下標
 * off爲low相對於下標0的偏移量
 */
private static void mergeSort(Object[] src,
                              Object[] dest,
                              int low,
                              int high,
                              int off) {
    int length = high - low;

    //一段精簡的插入排序代碼，INSERTIONSORT_THRESHOLD = 7
    // 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++];
    }
}

-----------分割線 by Tracy----------

另外附上https://stackoverflow.com/questions/8327514/comparison-method-violates-its-general-contract  這個回答。

----------第二條分割線--------------

我項目中寫過下面這個代碼：

Collections.sort(meetingList, new Comparator<Meeting>() {
    @Override
    public int compare(Meeting o1, Meeting o2) {
        long planStartTime1 = o1.getPlannedStartTime() == null ? 0 : o1.getPlannedStartTime();
        long planStartTime2 = o2.getPlannedStartTime() == null ? 0 : o2.getPlannedStartTime();
        return (int) (planStartTime1 - planStartTime2);
    }
});

就報了上面的錯誤。

 

估計主要仍是在於long轉int的時候出現了數據溢出，整個把符號給整反了！可能會形成比大小的結果不符合傳遞性