Java中子类重写compareTo方法的陷阱与Comparator的正确使用

class Parent implements Comparable<Parent> {
    int x;

    public Parent(int x) {
        this.x = x;
    }

    /**
     * 基于x进行排序
     */
    @Override
    public int compareTo(Parent other) {
        return Integer.compare(x, other.x);
    }

    @Override
    public String toString() {
        return "Parent{x=" + x + "}";
    }
}

class Child extends Parent { // 注意：Child不再直接实现Comparable<Child>
    int y;

    public Child(int x, int y) {
        super(x);
        this.y = y;
    }

    // 尝试直接重写 compareTo(Child other) 是不可能的，因为方法签名不匹配
    // 如果Child也实现Comparable<Child>，编译器会强制你实现 compareTo(Object) 或 compareTo(Parent)
    // 即使勉强实现，也会破坏契约。

    @Override
    public String toString() {
        return "Child{x=" + x + ", y=" + y + "}";
    }
}

// 这是一个无法编译或即使编译也违背契约的例子
class ChildBroken extends Parent implements Comparable<ChildBroken> {
    int y;

    public ChildBroken(int x, int y) {
        super(x);
        this.y = y;
    }

    // 编译器会报错，因为compareTo(ChildBroken other)不是有效的覆写
    // 即使强制转换为 Comparable<Parent> 或使用泛型技巧，也会破坏契约
    // @Override // 无法直接这样覆写
    // public int compareTo(ChildBroken other) {
    //     int c = super.compareTo(other); // 这里other是ChildBroken，但super.compareTo期望Parent
    //     if (c != 0) return c;
    //     return Integer.compare(y, other.y);
    // }

    // 实际上，如果Parent已经实现了Comparable<Parent>，Child实例仍然是Parent实例
    // 它的compareTo方法将是Parent的compareTo方法
}

Parent p = new Parent(10);
Child c1 = new Child(10, 5);
Child c2 = new Child(10, 20);

// 根据Parent的compareTo方法
System.out.println(p.compareTo(c1)); // 输出 0 (因为p.x == c1.x)
System.out.println(p.compareTo(c2)); // 输出 0 (因为p.x == c2.x)

// 如果我们期望c1.compareTo(c2)基于y值返回-1 (5 < 20)
// 但根据传递性契约：
// 如果 p.compareTo(c1) == 0 且 p.compareTo(c2) == 0
// 那么 c1.compareTo(c2) 必须也返回 0。
// 这与我们期望的 c1.compareTo(c2) == -1 产生了矛盾！
// 这种矛盾会导致依赖自然顺序的集合（如TreeSet）行为异常，例如元素丢失或顺序混乱。

import java.util.Comparator;
import java.util.TreeSet;

// Parent 和 Child 类保持不变，Child 不再实现 Comparable<Child>

// 定义一个自定义的Comparator，可以处理Parent和Child实例
Comparator<Parent> customHierarchyComparator = (obj1, obj2) -> {
    // 1. 首先比较x值
    int comparison = Integer.compare(obj1.x, obj2.x);
    if (comparison != 0) {
        return comparison; // x值不同，直接返回结果
    }

    // 2. 如果x值相同，处理Parent和Child的类型差异
    // 确保比较逻辑的完整性：Parent实例在Child实例之前，或者反之，或者根据具体需求定义
    // 这里定义：Parent实例优先于Child实例（当x相等时）
    // 如果obj1是Child而obj2不是Child，则obj1排在obj2之后 (+1)
    if (obj1 instanceof Child && !(obj2 instanceof Child)) {
        return 1;
    }
    // 如果obj1不是Child而obj2是Child，则obj1排在obj2之前 (-1)
    if (!(obj1 instanceof Child) && obj2 instanceof Child) {
        return -1;
    }

    // 3. 如果两者都是Child实例（且x相等），则比较y值
    if (obj1 instanceof Child && obj2 instanceof Child) {
        Child child1 = (Child) obj1;
        Child child2 = (Child) obj2;
        return Integer.compare(child1.y, child2.y);
    }

    // 4. 如果两者都不是Child实例（即都是Parent实例，且x相等），则认为相等
    return 0;
};

public class ComparatorExample {
    public static void main(String[] args) {
        // 使用自定义Comparator创建TreeSet
        TreeSet<Parent> myAwesomeSelfSortingSet = new TreeSet<>(customHierarchyComparator);

        Parent p1 = new Parent(10);
        Parent p2 = new Parent(20);
        Child c1 = new Child(10, 5);
        Child c2 = new Child(10, 20);
        Child c3 = new Child(20, 15);

        myAwesomeSelfSortingSet.add(p1);
        myAwesomeSelfSortingSet.add(p2);
        myAwesomeSelfSortingSet.add(c1);
        myAwesomeSelfSortingSet.add(c2);
        myAwesomeSelfSortingSet.add(c3);

        System.out.println("TreeSet elements sorted by custom comparator:");
        myAwesomeSelfSortingSet.forEach(System.out::println);

        // 预期输出顺序 (x升序，x相同时Parent在Child前，Child之间y升序):
        // Parent{x=10}
        // Child{x=10, y=5}
        // Child{x=10, y=20}
        // Parent{x=20} (或Child{x=20, y=15}，取决于Comparator中x相等时Parent和Child的相对顺序)
        // Child{x=20, y=15}

        // 验证上述Comparator的输出：
        // Parent{x=10}
        // Child{x=10, y=5}
        // Child{x=10, y=20}
        // Parent{x=20}
        // Child{x=20, y=15}
    }
}