“ Collections.sort（）”如何使用“ compare（）”方法的結果？

Question

Comparator接口中compare（）方法的輸出為-1,0或1。然后將其傳遞到Collections.sort（）方法，該方法可用於以自定義方式對列表進行排序。

但是sort（）對compare（）方法的結果有什么作用？ （-1,0或1）

我認為我最困惑的是compare（）的三個輸出為負，正或0）。 但是為什么算法不只需要其中兩個呢？ a = b時的動作不能與a> b或a <b時的動作相同嗎？ 所以我們真的不需要兩個輸出嗎？ （正負）

例如。 比較兩個數字a和b，如果a <b或a = b，則取a（例如compare（）返回-1），如果a> b，則取b（compare（）返回+1）。 為什么算法需要區分a <b和a = b？

例如。

class ReverseAlphabeticalComparator implements Comparator<Integer> {

@Override
public int compare(Integer i1, Integer i2) {
    if(i1 > i2) {
        return 1;
    }
    else if(i1 < i2) {
        return -1;
    }

    return 0;
}  

class App {
public static void main(String[] args) {

    List<Integer> animals = new ArrayList<Integer>();
    animals.add(6);
    animals.add(2);
    animals.add(4);
    animals.add(7);
    animals.add(8);
    animals.add(3);

    Collections.sort(numbers, new ReverseNumericalComparator());

        for(String numbers: numbers) {
            System.out.println(numbers); //Prints numbers in reverse eg. 8,7,6,4,3,2
        }
    }
}

Answer 1

但是sort（）對compare（）方法的結果有什么作用？

sort比較一系列元素對，並根據compare結果查看是否應該交換該對元素。

compare結果也不必是-1 0和1 。 從文檔

返回negative整數， zero或positive整數，因為第一個參數為
小於 ， 等於或大於秒。

Answer 2

對於我們要排序的集合中的每個元素，大多數（全部？）排序算法只需要知道a是否小於/大於/等於b 。 因此，您只需要從compare()返回一個負數，0或正數（在許多情況下為-1、0和1 compare() 。

如果您了解不同的排序算法，您會注意到它們是基於此的，從簡單的冒泡排序到快速排序，合並排序等。

Answer 3

這是它的作用（Collections.sort調用Arrays.sort，后者調用Arrays.mergeSort）：

private static void mergeSort(Object[] src,
                              Object[] dest,
                              int low, int high, int off,
                              Comparator c) {

    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 && c.compare(dest[j-1], 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, c);
    mergeSort(dest, src, mid, high, -off, c);

    // 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 (c.compare(src[mid-1], 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 && c.compare(src[p], src[q]) <= 0)
            dest[i] = src[p++];
        else
            dest[i] = src[q++];
    }
}