java - Equals 方法中浮点/ double 实例变量的相等比较是否应该准确？

Question

我正在重写对象的相等方法。假设里程表中的 km 变量存储为 double 型(以及一些对于示例而言并不重要的其他变量)。

public class Odometer { 
    private double km;

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        long temp;
        temp = Double.doubleToLongBits(km);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Odometer other = (Odometer) obj;
        if (Double.doubleToLongBits(km) != Double.doubleToLongBits(other.km))
            return false;
        return true;
    }
}

现在，Eclipse 生成的 double 变量(以及哈希码)的比较是精确的按位比较。但是，我被告知在比较浮点值或 double 值时要使用“epsilon”差异。我什至听说过这样的说法:“比较 float 时切勿使用相等性。”

boolean equals(double x, double y, double epsilon) { 
    return x - y < epsilon;
}

double 的 JUnit assertEquals 方法证明了这一点:

assertEquals(double expected, double actual, double epsilon)

那么，我应该在这里使用哪个比较？

Answer 1

equals 方法的 Javadoc 指出(强调我的):

https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#equals-java.lang.Object-

The equals method implements an equivalence relation on non-null object references:

• It is reflexive: for any non-null reference value x, x.equals(x) should return true.
• It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
• It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
• It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
• For any non-null reference value x, x.equals(null) should return false.

相等方法必须是传递的。如果您使用了 epsilon，则这将不成立。

考虑 double 值 x = 2.0、y = 2.6、z = 3.1 和 epsilon = 1.0。

请注意，z - y = 0.5 和 y - x = 0.6，两者都小于 1.0 的 epsilon。但是，z - x = 1.1，大于 1.0。

因此，我们会得到“x equals y”和“y equals z”，但不会得到“x equals z”，这会破坏传递性。如果这些是某些其他对象的实例变量(例如上面示例中的里程表)，也会发生同样的情况。

因此相等应该是精确的。按照上面的方式转换为位，就像使用 Double.compare(double d1, double d2) 或将它们转换为 Double 值然后使用 Double.compareTo(Double anotherDouble) 一样。 。请注意，它们会将 0.0 和 -0.0 视为不同的数字。

https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#compare-double-double- https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#compareTo-java.lang.Double-

这对于保持哈希函数的一致性也很重要。

即使对于原始 double 值，也不要使用内置的 Java 相等运算符 ==。正如 JavaDocs 中有关 compareTo 方法的说明，相等失败并返回 NaN。 (这个 StackOverflow 问题还有一些更多信息:Why is Java's Double.compare(double, double) implemented the way it is?)

最后一点 - 这不适用于上面的示例，因为使用了原始 double 值，但如果您使用 Double 对象，请记住在之前检查 null尝试将它们传递到任何 Double 比较函数中。