在Groovy中,为什么'=='的行为会改变扩展Comparable的接口？

Question

我正在尝试在Groovy中开发一个项目,并且我发现我的一些测试以一种奇怪的方式失败:我有一个Version extends Comparable<Version>带有两个具体子类的接口.这二者都会覆盖equals(Object)和compareTo(Version)-但是,如果我尝试比较的两个实例Version正在使用不同的具体类型==,平等检查失败,即使明确equals和compareTo检查通过.

如果我删除了extends Comparable<Version>部分Version,我得到了预期的行为 - ==给出了相同的结果equals.

我已经在其他地方读过Groovy代表==,equals()除非该类实现Comparable,在这种情况下它委托给compareTo.但是,我发现两个都声明两个实例Version相等然后==检查失败的情况.

我创建演示此行为的SSCCE 这里.

完整代码也在下面提供:

// Interface extending Comparable
interface Super extends Comparable<Super> {
    int getValue()
}

class SubA implements Super {
    int getValue() { 1 }
    int compareTo(Super that) { this.value <=> that.value }
    boolean equals(Object o) {
        if (o == null) return false
        if (!(o instanceof Super)) return false
        this.value == o.value
    }
}

class SubB implements Super {
    int getValue() { 1 }
    int compareTo(Super that) { this.value <=> that.value }
    boolean equals(Object o) {
        if (o == null) return false
        if (!(o instanceof Super)) return false
        this.value == o.value
    }
}

// Interface not extending Comparable
interface AnotherSuper {
    int getValue()
}

class AnotherSubA implements AnotherSuper {
    int getValue() { 1 }
    boolean equals(Object o) {
        if (o == null) return false
        if (!(o instanceof AnotherSuper)) return false
        this.value == o.value
    }
}

class AnotherSubB implements AnotherSuper {
    int getValue() { 1 }
    boolean equals(Object o) {
        if (o == null) return false
        if (!(o instanceof AnotherSuper)) return false
        this.value == o.value
    }
}


// Check with comparable versions
def a = new SubA()
def b = new SubB()

println "Comparable versions equality check: ${a == b}"
println "Explicit comparable equals check: ${a.equals(b)}"
println "Explicit comparable compareTo check: ${a.compareTo(b)}"

// Check with non-comparable versions
def anotherA = new AnotherSubA()
def anotherB = new AnotherSubB()

println "Non-comparable versions equality check: ${anotherA == anotherB}"
println "Explicit non-comparable equals check: ${anotherA.equals(anotherB)}"

我得到的回报是:

Comparable versions equality check: false
Explicit comparable equals check: true
Explicit comparable compareTo check: 0
Non-comparable versions equality check: true
Explicit non-comparable equals check: true

编辑
我想我明白为什么现在发生这种情况,这要归功于Poundex与下面的JIRA讨论.

从Groovy的DefaultTypeTransformation类(用于处理相等/比较检查)开始,我假设在评估compareEqual表单的语句时首先调用该方法x == y:

public static boolean compareEqual(Object left, Object right) {
    if (left == right) return true;
    if (left == null || right == null) return false;
    if (left instanceof Comparable) {
        return compareToWithEqualityCheck(left, right, true) == 0;
    }
    // handle arrays on both sides as special case for efficiency
    Class leftClass = left.getClass();
    Class rightClass = right.getClass();
    if (leftClass.isArray() && rightClass.isArray()) {
        return compareArrayEqual(left, right);
    }
    if (leftClass.isArray() && leftClass.getComponentType().isPrimitive()) {
        left = primitiveArrayToList(left);
    }
    if (rightClass.isArray() && rightClass.getComponentType().isPrimitive()) {
        right = primitiveArrayToList(right);
    }
    if (left instanceof Object[] && right instanceof List) {
        return DefaultGroovyMethods.equals((Object[]) left, (List) right);
    }
    if (left instanceof List && right instanceof Object[]) {
        return DefaultGroovyMethods.equals((List) left, (Object[]) right);
    }
    if (left instanceof List && right instanceof List) {
        return DefaultGroovyMethods.equals((List) left, (List) right);
    }
    if (left instanceof Map.Entry && right instanceof Map.Entry) {
        Object k1 = ((Map.Entry)left).getKey();
        Object k2 = ((Map.Entry)right).getKey();
        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
            Object v1 = ((Map.Entry)left).getValue();
            Object v2 = ((Map.Entry)right).getValue();
            if (v1 == v2 || (v1 != null && DefaultTypeTransformation.compareEqual(v1, v2)))
                return true;
        }
        return false;
    }
    return ((Boolean) InvokerHelper.invokeMethod(left, "equals", right)).booleanValue();
}

请注意,如果表达式的LHS是Comparable我提供的示例中的实例,则将比较委派给compareToWithEqualityCheck:

private static int compareToWithEqualityCheck(Object left, Object right, boolean equalityCheckOnly) {
    if (left == right) {
        return 0;
    }
    if (left == null) {
        return -1;
    }
    else if (right == null) {
        return 1;
    }
    if (left instanceof Comparable) {
        if (left instanceof Number) {
            if (right instanceof Character || right instanceof Number) {
                return DefaultGroovyMethods.compareTo((Number) left, castToNumber(right));
            }
            if (isValidCharacterString(right)) {
                return DefaultGroovyMethods.compareTo((Number) left, ShortTypeHandling.castToChar(right));
            }
        }
        else if (left instanceof Character) {
            if (isValidCharacterString(right)) {
                return DefaultGroovyMethods.compareTo((Character)left, ShortTypeHandling.castToChar(right));
            }
            if (right instanceof Number) {
                return DefaultGroovyMethods.compareTo((Character)left,(Number)right);
            }
        }
        else if (right instanceof Number) {
            if (isValidCharacterString(left)) {
                return DefaultGroovyMethods.compareTo(ShortTypeHandling.castToChar(left),(Number) right);
            }
        }
        else if (left instanceof String && right instanceof Character) {
            return ((String) left).compareTo(right.toString());
        }
        else if (left instanceof String && right instanceof GString) {
            return ((String) left).compareTo(right.toString());
        }
        if (!equalityCheckOnly || left.getClass().isAssignableFrom(right.getClass())
                || (right.getClass() != Object.class && right.getClass().isAssignableFrom(left.getClass())) //GROOVY-4046
                || (left instanceof GString && right instanceof String)) {
            Comparable comparable = (Comparable) left;
            return comparable.compareTo(right);
        }
    }

    if (equalityCheckOnly) {
        return -1; // anything other than 0
    }
    throw new GroovyRuntimeException(
            MessageFormat.format("Cannot compare {0} with value ''{1}'' and {2} with value ''{3}''",
                    left.getClass().getName(),
                    left,
                    right.getClass().getName(),
                    right));
}

在底部附近,该方法具有将比较委托给方法的块compareTo,但仅在满足某些条件的情况下.在我提供的示例中,没有满足这些条件,包括isAssignableFrom检查,因为我提供的示例类(以及我项目中给出问题的代码)是兄弟,因此不能彼此分配.

我想我明白为什么检查现在失败了,但我仍然对以下事情感到困惑:

1. 我该如何解决这个问题？
2. 这背后的理由是什么？这是一个错误或设计功能吗？是否有任何理由说明为什么普通超类的两个子类不能相互比较？

Answer 1

如果现有的话，为什么 Comparable 用于 == 的答案很简单。这是因为BigDecimal。如果你用“1.0”和“1.00”创建一个 BigDecimal（使用字符串而不是双精度数！），你会得到两个根据 equals 不相等的 BigDecimal，因为它们没有相同的标度。但就值而言，它们是相等的，这就是为什么compareTo 会将它们视为相等的原因。

当然还有GROOVY-4046，它展示了直接调用compareTo会导致ClassCastException的情况。由于此异常在这里是意外的，我们决定添加可分配性检查。

为了解决这个问题，你可以使用<=>你已经找到的。是的，它们仍然会经过DefaultTypeTransformation，因此您可以比较 int 和 long 等。如果您也不希望这样，那么直接调用compareTo就是正确的方法。如果我误解了你，而你实际上想要 equals，那么你当然应该调用 equals。