假设我有一个简单的接口(interface)，我希望基于某些功能Comparable:

interface Organism extends Comparable<Organism> {
    String getName();
    int getComplexity();

    @Override
    default int compareTo(Organism other) {
        return this.getComplexity() - other.getComplexity();
    }
}

每个实现类都必须返回一个唯一的复杂性，因此一个类的任何两个实例都将具有相同的复杂性，而不同类的任何两个实例将具有不同的复杂性。自然排序会将类的所有实例“组合”在一起。

我现在想在一个类中实现此接口(interface)，该类覆盖默认比较，专门用于按顺序比较该类的实例组中该类的两个实例。我使用以下模式:

class Bacteria implements Organism {
    enum Shape {ROD, ROUND, SPIRAL};
    private final Shape shape;

    @Override
    public int compareTo(Organism other) {
        if (other instanceof Bacteria)
            return this.shape.compareTo((Bacteria)other.shape);
        else
            return Organism.super.compareTo(other);
    }
}

我对这种代码模式不是特别满意:一旦实现接口(interface)的类集变大，维护起来就会变得非常复杂，需要大量重复代码，并且取决于“复杂性”的隐式属性。我更喜欢定义顺序的 Comparator 风格。我希望能够在 Bacteria 中使用如下所示的方式实现 Comparable:

return Comparator
    .comparingInt(Organism::getComplexity)
    .thenComparing(Bacteria::getShape);

需要明确的是，我意识到比较器不是这样工作的:它们的设计使得一个比较器在整个集合中使用，而不是根据每个对象使用不同的比较器。我在这里提到它们并不是因为它们是一个潜在的解决方案，而是因为比较器的链接风格优雅而透明。我感兴趣的是是否有一种类似的优雅方式来定义 compareTo 以允许集合中的不同排序取决于类。

最佳答案

我不确定你打算把 Comparator 放在哪里.由于您希望您的类(class)实现 Comparable<Organism> , 我假设你正在寻找类似的东西

class Bacteria implements Organism {
    enum Shape {ROD, ROUND, SPIRAL};
    private final Shape shape;

    Comparator<Organism> comparator = 
        Comparator
            .comparingInt(Organism::getComplexity)
            .thenComparing(Bacteria::shape);  // illegal

    @Override
    public int compareTo(Organism other) {
        return comparator.compare(this, other);
    }
}

这行不通，因为 thenComparing , 在上下文中，需要一个参数 Function在 Organism 上运行, 不是 Bacteria .您可以像这样解决它——我会留给您来决定这是否足够优雅:

Comparator<Organism> comparator = 
    Comparator
        .comparingInt(Organism::getComplexity)
        .thenComparing(x -> ((x instanceof Bacteria) ? ((Bacteria)x).getShape() : Shape.ROD));

理论上，您也可以编写自己的方法，将比较器转换为另一个。你不能使用 instance.method符号，所以使用必须是这样的:

Comparator<Organism> comparator = 
   MyComparatorUtilities.thenComparingIfInstanceOf(
        Comparator.comparingInt(Organism::getComplexity),
        Bacteria.class,
        Bacteria::getShape);

thenComparingIfInstanceOf的以下实现编译(并允许编译上面的代码)，但我还没有尝试测试它:

class MyComparatorUtilities {
    public static 
    <T,U extends T,V extends Comparable<? super V>> Comparator<T> thenComparingIfInstanceOf(
        Comparator<T> comparator,
        Class<U> subclass,
        Function<? super U, ? extends V> keyExtractor) {
        return (a, b) -> {
            int comp = comparator.compare(a, b);
            if (comp != 0) {
                return comp;
            }
            if (subclass.isInstance(a) && subclass.isInstance(b)) {
                return keyExtractor.apply(subclass.cast(a))
                    .compareTo(keyExtractor.apply(subclass.cast(b)));
            }
            return 0;
        };
    }
}

更多:回答评论:不，我不一定认为这种方法更具可读性或可维护性。事实上，我认为整个设计是不可维护的，因为添加一个类太容易导致比较违反总排序的属性；我会寻找不同的设计，从更清晰地定义我希望如何对不同类的对象进行排序开始。处理比较的“正确”方式可能取决于不同的设计。

对于类似的问题，我可能会坚持使用 compareTo方法，除非我需要一个类来返回 Comparator出于某些其他原因(例如，为 Organism 定义了多个顺序)。但是，我可能会寻找消除重复的方法，如果每个 compareTo是一个 if具有相同结构的语句，或类似的东西。

关于java - 实现接口(interface)比较器，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33050130/