为什么我的比较方法违反了它的总契约？

Question

public static Comparator<Container> DEPARTURE = new Comparator<Container>() {
    @Override
    public int compare(Container container1, Container container2) {
        if (container1.departure.time.isBefore(container2.departure.time))
            return -1;
        else if (container1.departure.time.equals(container2.departure.time) && 
                 container1.departure.maxDuration == container2.departure.maxDuration && 
                 container1.departure.transportCompany.equals(container2.departure.transportCompany) && 
                 container1.departure.transportType == container2.departure.transportType)
            return 0;
        else
            return +1;
    }
};

偏离变量只是包含以下字段的对象的一个实例:

    public DateTime time;
    public int maxDuration;
    public TransportType transportType;
    public String transportCompany;

附言时间对象是来自 Joda-Time 库的 DateTime 实例，TransportType 是包含常量火车、海船、驳船和卡车的枚举。

编辑：

好的，所以我将比较器编辑为以下内容：

    public static Comparator<Container> DEPARTURE = new Comparator<Container>() {
        @Override
        public int compare(Container container1, Container container2) {
            if (container1.departure.time.isBefore(container2.departure.time))
                return -1;
            else if (container1.departure.time.isBefore(container2.departure.time))
                return +1;
            else {
                if (container1.departure.maxDuration == container2.departure.maxDuration && container1.departure.transportType == container2.departure.transportType && container1.departure.transportCompany.equals(container2.departure.transportCompany))
                    return 0;
                else
                    return +1;
            }
        }
    };

但这显然违反了一般契约。我如何让它按时间排序，然后根据它们的其他属性对那些具有相等时间的对象进行排序，只关心它们是否相等？希望这有意义…

编辑:解决方案

谢谢大家回答我的问题！在研究了你的评论后，我想出了下面的解决方案，它似乎是有效的(尽管还没有经过彻底的测试):

我实际上将比较部分移到了离开他的班级，因为我也需要按到达进行比较。我决定简单地按所有属性（连续时间、最大持续时间、传输公司和运输类型）进行排序，我想出的解决方案是：

    public static Comparator<Container> ARRIVAL = new Comparator<Container>() {
        @Override
        public int compare(Container container1, Container container2) {
            return container1.arrival.compareTo(container2.arrival);
        }
    };

    public static Comparator<Container> DEPARTURE = new Comparator<Container>() {
        @Override
        public int compare(Container container1, Container container2) {
            return container1.departure.compareTo(container2.departure);
        }
    };

然后使用compareTo方法：

    @Override
    public int compareTo(LocationMovement lm) {
        if (this.time.isBefore(lm.time))
            return -1;
        else if (this.time.isAfter(lm.time))
            return +1;
        else {
            int c = this.maxDuration - lm.maxDuration;
            if (c != 0) return c;

            c = this.transportCompany.compareTo(lm.transportCompany);
            if (c != 0) return c;

            c = this.transportType.ordinal() - lm.transportType.ordinal();
            return c;
        }
    }

Answer 1

请注意，如果两个容器< code>c1和< code>c2具有相同的< code > department . time ，但其他属性不同，则< code>compare(c1，c2)和< code>compare(c2，c1)都将返回< code> 1，即< code>c1

相反，您应该完全删除其他字段，或者在出发时间相等的情况下在嵌套或顺序 if-elses 中单独比较它们。

看看这个相关问题的答案，了解一种通过多个属性比较对象的干净方法。

Answer 2

为了实现compare，您检查的所有项目都必须具有相互“较小”、“较大”或“相等”的概念，然后您必须决定检查它们的顺序，对第一个不相等的项目返回较小/较大。这样，您就满足了合同，即compare（a，b）必须是compare（b，a）的反面。如果您正在比较的所有部分都没有“较大”或“较小”的概念（例如，传输类型），那么要么您无法实现compare，要么您必须强制对它们进行任意（但可靠）的较大/较小解释。

这是一个概念性的例子。在这种情况下，我选择的顺序(任意)是:时间、持续时间、公司和类型。但是不同的顺序可能更合理。这只是一个例子。此外，您还没有说明< code>transportType的类型是什么，所以我假设它有一个< code>compareTo方法；显然，它可能不会，你可能需要调整。

public static Comparator<Container> DEPARTURE = new Comparator<Container>() {
    @Override
    public int compare(Container container1, Container container2) {
        int rv;

        // Times
        rv = container1.departure.time.compareTo(container2.departure.time);
        if (rv == 0) {
            // Duration
            if (container1.departure.maxDuration < container2.departure.maxDuration) {
                rv = -1;
            }
            else if (container1.departure.maxDuration > container2.departure.maxDuration) {
                rv = 1;
            }
            else {
                // Transport company
                rv = container1.departure.transportCompany.compareTo(container2.departure.transportCompany);
                if (rv == 0) {
                    // Transport type
                    rv = container1.departure.transportType.compareTo(container2.departure.transportType);
                }
            }
        }
        return rv;
    }
};

Answer 3

一般合同是

COMPARATOR.compare(a, b) = - COMPARATOR.compare(b, a)

在您的例子中，一方面返回-1的代码可能另一方面返回0。