[Java]實現Comparable接口不嚴謹導致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++]; } }