实现接口比较器-解网

问：

假设我有一个简单的，我希望基于某些功能：interfaceComparable

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

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

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

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

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);
    }
}

我对这种代码模式不是特别满意：一旦实现接口的类集变得很大，维护起来就会变得非常复杂，需要大量重复的代码，并且依赖于“复杂性”的隐式属性。我更喜欢定义顺序的风格。我希望能够使用如下所示的东西来实现：ComparatorComparableBacteria

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

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

Java 比较

once the set of classes implementing the interface becomes large it becomes quite complex to maintain- 为什么你认为维护起来会变得复杂？您是否预见到，需要根据其他类扩展来更改方法？或者你认为维护起来会很复杂，因为整个层次结构的比较逻辑分散在子类中？compareToBacteriaOrganism

答：

0赞 ajb 10/10/2015 #1

我不确定你打算把.既然你希望你的类实现，我假设你正在寻找类似的东西ComparatorComparable<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);
    }
}

这是行不通的，因为在上下文中，需要一个参数，该参数是，该参数对而不是 .你可以这样解决它 - 我会让你决定这是否足够优雅：thenComparingFunctionOrganismBacteria

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;
        };
    }
}

更多：回答评论：不，我不一定认为这种方法更具可读性或可维护性。事实上，我认为整个设计是不可维护的，因为添加一个类太容易了，这会导致比较违反总排序的属性;我会寻找一种不同的设计，首先要更清楚地定义我希望排序如何对不同类的对象起作用。处理比较的“正确”方法可能取决于不同的设计。

对于类似的问题，我可能会坚持使用一种方法，除非出于其他原因（例如，为 s 定义了多个排序）需要一个类来返回 a。但是，我可能会寻找消除重复的方法，如果每个都是具有相同结构的语句，或者类似的东西。compareToComparatorOrganismcompareToif

@ajb 谢谢你的回答。我不一定不同意你关于设计问题的看法——我不喜欢它只能通过在复杂性上合作的实现来工作。尽管我对如何优雅地实现这一点感兴趣：如何允许接口的实现定义自己的排序机制。我不确定我是否在任何标准代码中看到过一个很好的例子，它不会增加很多不必要的复杂性。

0赞 Rob 11/3/2017 #2

您可以执行以下操作：

return Comparator
      .comparingInt(Organism::getComplexity)
      .thenComparing(o-> o instanceof Bacteria ? 
             ((Bacteria) o).getShape() : Bacteria.Shape.ROD);

因此，如果它是一个细菌，那么它会比较形状，否则它会比较一个相同类型的常数，这些常量总是相等的。如果在比较中不使用相同的类型，则不会编译。

这不是一个通用接口，但也许这会帮助那些试图比较有限数量的子类的属性的其他人。

上一个：__eq__（）多次调用，而不是在嵌套数据结构中调用一次

下一个：比较 connection_hdl （weak_ptr）的相等性

实现接口比较器

Implementing interface comparators

评论

评论