java Double.hashCode返回 `Double` 对象的哈希码

一、方法定义

Double.hashCode() 是 java.lang.Double 类的实例方法，用于返回 Double 对象的哈希码（hash code），主要在哈希表集合（如 HashMap、HashSet、Hashtable）中用于快速定位对象。

方法签名：

public int hashCode()

参数：无。
返回值：一个 int 类型的哈希码。
无异常抛出：该方法是安全的，不会抛出异常。

💡 注意：Double.hashCode() 是实例方法，而 Double.hashCode(double value) 是 Java 8+ 引入的 静态方法，两者功能一致。

静态方法签名：

public static int hashCode(double value)

二、功能说明

生成哈希码：根据 double 值的内容生成一个整数哈希码。
哈希码一致性要求：
- 如果两个 Double 对象通过 equals() 比较相等，则它们的 hashCode() 必须返回相同的值。
- 这是 Object.hashCode() 合约的核心要求。
特殊值处理：
- Double.NaN 的哈希码是固定的：0x7fc00000（即 2146959360）。
- +0.0 和 -0.0 被视为相等（equals() 返回 true），因此它们的哈希码也必须相同。
实现原理：
- 将 double 值转换为其 64 位 IEEE 754 浮点表示（long 类型）。
- 然后通过异或操作，将高 32 位与低 32 位合并为一个 int 哈希码：
```
(int)(bits ^ (bits >>> 32))
```
  其中 bits = Double.doubleToLongBits(value)。

三、示例代码

示例 1：基本用法

Double d1 = 3.14;
Double d2 = 3.14;

System.out.println(d1.hashCode()); // 输出: 某个整数（如 1078523331）
System.out.println(d2.hashCode()); // 输出: 与 d1 相同

System.out.println(d1.hashCode() == d2.hashCode()); // true

示例 2：`+0.0` 和 `-0.0` 的哈希码

Double positiveZero = +0.0;
Double negativeZero = -0.0;

System.out.println(positiveZero.equals(negativeZero)); // true
System.out.println(positiveZero.hashCode()); // 输出: 0
System.out.println(negativeZero.hashCode()); // 输出: 0（相同！）

示例 3：`NaN` 的哈希码

Double nan1 = Double.NaN;
Double nan2 = 0.0 / 0.0;

System.out.println(nan1.equals(nan2)); // true（所有 NaN 相等）
System.out.println(nan1.hashCode()); // 输出: 2146959360
System.out.println(nan2.hashCode()); // 输出: 2146959360（固定值）

示例 4：使用静态方法（Java 8+）

int hash1 = Double.hashCode(3.14);
int hash2 = Double.hashCode(Double.NaN);

System.out.println(hash1); // 与 new Double(3.14).hashCode() 相同
System.out.println(hash2); // 2146959360

示例 5：在 `HashMap` 中使用

Map<Double, String> map = new HashMap<>();
map.put(3.14, "Pi");
map.put(2.71, "Euler");

System.out.println(map.get(3.14)); // 输出: Pi（依赖 hashCode 和 equals）

四、使用技巧

自定义类中正确重写 hashCode
若你的类包含 double 字段，应使用 Double.hashCode(field) 生成哈希码。

@Override
public int hashCode() {
    return Objects.hash(this.value); // Objects.hash 内部调用 Double.hashCode
    // 或手动：
    // return Double.hashCode(this.value);
}

静态方法避免创建对象
在需要哈希码但无需 Double 对象时，使用 Double.hashCode(double) 避免装箱开销。
理解 NaN 的特殊性
所有 NaN 值被视为相等，哈希码固定，确保在集合中行为一致。
+0.0 和 -0.0 视为相同
在设计算法或比较逻辑时注意，它们在 equals 和 hashCode 上无区别。

五、常见错误

❌ 错误 1：认为 +0.0 和 -0.0 哈希码不同
✅ 实际上，Double 类明确保证它们的 hashCode 相同，因为 equals() 返回 true。

❌ 错误 2：手动计算哈希码不一致

// ❌ 错误：未处理 NaN 和 ±0
public int badHashCode() {
    return (int) this.value; // 完全错误！
}

// ❌ 错误：直接使用 doubleToLongBits 但未合并
long bits = Double.doubleToLongBits(value);
return (int) bits; // 丢失高32位信息

✅ 正确做法：使用 Double.hashCode(value)。

❌ 错误 3：在 equals 中使用 == 比较 double

// ❌ 错误：未处理 NaN、±0
public boolean equals(Object o) {
    if (o instanceof MyDouble) {
        return this.value == ((MyDouble)o).value;
    }
    return false;
}

✅ 正确：

public boolean equals(Object o) {
    if (o instanceof MyDouble) {
        return Double.compare(this.value, ((MyDouble)o).value) == 0;
        // 或 Double.doubleToLongBits(...) 比较
    }
    return false;
}

六、注意事项

NaN 的哈希码是固定的 0x7fc00000，不是随机的。
+0.0 和 -0.0 的哈希码均为 0。
性能：hashCode() 计算非常快，基于位运算。
线程安全：Double 对象是不可变的，因此 hashCode() 是线程安全的。
与 float 类似：Float.hashCode() 有类似逻辑，但基于 32 位。

七、最佳实践

✅ 推荐做法：

在重写 hashCode 时使用 Double.hashCode()

public final class Point {
    private final double x, y;

    @Override
    public int hashCode() {
        return Objects.hash(x, y); // 推荐
        // 或：31 * Double.hashCode(x) + Double.hashCode(y);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Point)) return false;
        Point p = (Point) o;
        return Double.compare(p.x, x) == 0 &&
               Double.compare(p.y, y) == 0;
    }
}

优先使用静态方法 Double.hashCode(double)
避免不必要的 Double 对象创建。
理解浮点数的局限性
double 有精度问题，直接比较可能不准确，equals 和 hashCode 基于精确位表示。
避免在 hashCode 中使用 ==
使用 Double.compare() 或 Double.doubleToLongBits() 进行精确比较。

八、性能优化

场景	推荐方法	说明
获取 `Double` 对象哈希码	`doubleObj.hashCode()`	标准方式
获取 `double` 值哈希码	`Double.hashCode(value)`	避免装箱，更高效
手动实现	使用 `Objects.hash()`	简洁、正确
高频计算	缓存哈希码（若对象可变）	`Double` 不可变，无需缓存

⚡ 性能提示：Double.hashCode() 是高效位运算，无需担心性能。

九、总结

Double.hashCode() 是确保 Double 对象在哈希集合中正确行为的关键方法。它遵循 Object.hashCode() 合约，特别处理了 NaN、+0.0 和 -0.0 等浮点数特殊值。

✅ 核心要点速查：

项目	说明
功能	为 `double` 值生成哈希码
`NaN` 哈希码	固定为 `0x7fc00000`（2146959360）
`±0.0` 哈希码	均为 `0`
实现方式	`longBits ^ (longBits >>> 32)`
静态方法	`Double.hashCode(double)`（Java 8+）
最佳实践	与 `equals` 一致，用于 `HashMap`/`HashSet`

🚀 实践口诀：

“Double 取哈希，hashCode 是专家；NaN 固定 0x7fc00000，±0 都是零不怕。”