java - Double.doubleToLongBits(x) 的含义

Question

我正在编写一个类 Vec2D，表示一个二维 vector 。我将 x 和 y 存储在 double 中。

当要求生成 equals(Object obj 和 hashCode() 时，eclipse 生成了这个:

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    long temp;
    temp = Double.doubleToLongBits(x);
    result = prime * result + (int) (temp ^ (temp >>> 32));
    temp = Double.doubleToLongBits(y);
    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;
    Vec2D other = (Vec2D) obj;
    if (Double.doubleToLongBits(x) != Double.doubleToLongBits(other.x))
        return false;
    if (Double.doubleToLongBits(y) != Double.doubleToLongBits(other.y))
        return false;
    return true;
}

在这种情况下，Double.doubleToLongBits(x) 的意义是什么？我不能简单地写 x != other.x 吗？

Answer 1

简短回答:Eclipse 使用 Double.doubleToLongBits因为这就是Double.equals做:

The result is true if and only if the argument is not null and is a Double object that represents a double that has the same value as the double represented by this object. For this purpose, two double values are considered to be the same if and only if the method doubleToLongBits(double) returns the identical long value when applied to each.

长答案:JLS 指定了 Double.equals 和 == 之间的一些差异。对于 JLS 4.2.3 中指定的一个差异和 JLS 15.21.1 :

Positive zero and negative zero compare equal; thus the result of the expression 0.0==-0.0 is true and the result of 0.0>-0.0 is false. But other operations can distinguish positive and negative zero; for example, 1.0/0.0 has the value positive infinity, while the value of 1.0/-0.0 is negative infinity.

另一个关于 NaN 的问题:

If either operand is NaN, then the result of == is false but the result of != is true.

Indeed, the test x!=x is true if and only if the value of x is NaN.

如您所见，两个 double 值可以与 == 进行比较，但在数学和哈希表中使用时实际上对应于不同的行为。因此，在编写生成的相等方法时，Eclipse 假设只有当且仅当可以对它们执行的所有操作都相同时，或者(等效地)如果它们被自动装箱并与它们的 等值进行比较，两个 double 才相等 方法。如果在 double 和 Double 之间切换，这一点尤其重要——如果相等属性在那里有所不同，那将是特别出乎意料的。

当然，您可以自由地偏离该假设:无论这是否是一个好主意，您都可以将特殊情况分配给许多可能的 NaN 表示中的任何一种，在这种情况下 Double.doubleToRawLongBits() 会更好地匹配您的 equals 和 hashCode 方法。出于同样的原因，您的用例可能会将具有 +0.0 和 -0.0 的对象视为等效对象，并保证不可能出现 NaN 值，在这种情况下，原始 == 比较可能对 更有效等于(但此时为 hashCode 模拟相同的标准变得困难)。