java - java中实现Comparable<T>时返回-1和1

Question

class Employee implements Comparable<Employee> {
    int id;
    String name;
    int age;

    Employee(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int compareTo(Employee employee) {
        /*if (age == employee.age)
            return 0;
        else if (age > employee.age)
            return 1;
        else
            return -1;*/
        return -1;
    }
}



public class TestSorting {
    public static void main(String args[]) {
        ArrayList<Employee> al = new ArrayList<Employee>();
        al.add(new Employee(101, "Peter", 23));
        al.add(new Employee(106, "Marry", 29));
        al.add(new Employee(105, "John", 21));
        //Before sorting
        for (Employee st : al) {
            System.out.println(st.id + " " + st.name + " " + st.age);
        }
        System.out.println("================");
        //After sorting
        Collections.sort(al);
        for (Employee st : al) {
            System.out.println(st.id + " " + st.name + " " + st.age);
        }
    }
}

第一次，我重写了方法compareTo:

if (age == employee.age)
    return 0;
else if (age > employee.age)
    return 1;
else
    return -1;

结果是:

101 Peter 23
106 Marry 29
105 John 21
================
105 John 21
101 Peter 23
106 Marry 29

第二次我重写此方法时，除了 return -1 之外，正文中没有任何内容。本以为排序后的结果应该和原来一样，结果却相反。而当我在方法 conpareTo 中 return 1 时，结果与原始结果相同，这不是我所期望的。这就是我在 compareTo 方法中 return -1 的结果:

101 Peter 23
106 Marry 29
105 John 21
================
105 John 21
106 Marry 29
101 Peter 23

新更新:

我认为当返回-1时，不应该发生任何事情的原因是。根据排序算法，对数组进行排序时，我们可以这样做: 我们可以使用这个算法:

public class Test {
    public static void main(String[] args) {
        int[] arr = { 6, 9, 3, 5, 7, 1, 8 };
        System.out.println(Arrays.toString(arr));
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));

    }
}

我认为 Comparable 的算法看起来像这个算法。所以当方法中返回-1时，那么这个年龄总是小于那个年龄；所以没有交换(就像arr[i] > arr[j]总是false，并且没有交换)。而当返回1时，就意味着这个年龄总是大于那个年龄，所以存在交换(就像arr [i] > arr[j] 始终为 true，并且存在交换)，结果是与原始数组相比顺序相反的数组。 如果我们将代码更改为:

for (int i = 0; i < arr.length - 1; i++) {
        for (int j = i; j < arr.length; j++) {
            if (true) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }

我们得到结果:

[6, 9, 3, 5, 7, 1, 8]
[8, 1, 7, 5, 3, 9, 6]

这就是为什么我认为在 compareTo 方法中 return 1 的原因。我们应该将原始列表倒序放入列表中。但事实并非如此。当 return -1

时我们就得到了结果

Answer 1

The second time I override this method with nothing in the body except return -1 ...

这样做您就违反了 Comparable 的契约(Contract)，即defined in the documentation 。你说一切都比其他一切都要少，这不可能是真的。

A < B和B < A这是一个悖论。

因此，期望顺序不变是错误的期望。当您违反Comparable的契约(Contract)时，排序行为未定义。没有比任何其他结果或多或少正确的结果。