哈希码计算公式是否应随变量范围调整？Dice类哈希优化咨询

针对你用Dice类练习哈希码实现的几个问题，结合你提到的实际变量范围（骰子数≤10，面数≤100），直接给你明确结论和实操建议：

1. 创建哈希码公式时需要考虑变量范围吗？ #

当然需要，而且你的场景刚好可以利用范围做零碰撞、绝对均匀的哈希实现。

因为你的变量实际取值范围很小：numDice最多10，numSides最多100，两者的乘积（1000）远小于int的取值上限。你完全可以用「大质数乘数+变量相加」的方式，直接让每个合法的Dice实例对应唯一的哈希码。比如：

@Override
public int hashCode() {
    // 选101是因为它大于最大面数100，且是质数，避免不同组合产生相同值
    return numDice * 101 + numSides;
}

这种方式比通用的Objects.hash()更高效，而且完全不会有哈希碰撞，分布绝对均匀。当然Objects.hash()也能用，但对于你的场景来说有点“杀鸡用牛刀”，而且可能存在极低的碰撞概率。

2. 变量顺序会有影响吗？ #

有影响，而且必须和你的equals()方法逻辑对应。

比如Dice(5,6)（5颗6面）和Dice(6,5)（6颗5面）是完全不同的实例，它们的哈希码必须不同。如果你的equals()方法里是先比较numDice再比较numSides，那哈希码的变量组合顺序也要保持一致，不能搞反——否则会出现「两个实例equals返回true，但哈希码不同」的错误，这违反了哈希码的基本约定。

另外，不同的顺序会改变哈希码的生成结果，比如Objects.hash(numSides, numDice)和Objects.hash(numDice, numSides)的哈希值大概率不同，只要能区分不同实例，顺序本身没有绝对的好坏，关键是要和equals()的逻辑匹配。

3. 怎么测试哈希码公式的优劣？ #

核心测两点：碰撞率和分布均匀性，结合你的场景，直接用代码跑一遍所有可能的实例就行：

碰撞率测试 #

因为你的合法实例最多只有10*100=1000个，直接遍历所有组合，统计重复的哈希码数量。理想情况是0碰撞（比如上面的numDice*101+numSides就能做到），如果用Objects.hash()，碰撞数应该很少，但肯定不如自定义的完美。

分布均匀性测试 #

模拟HashMap的桶分配逻辑（通常是用哈希码和桶数-1做按位与），统计每个桶里的实例数量。如果每个桶的数量差异很小，说明分布均匀——比如1000个实例分到16个桶，每个桶应该在62-63个左右，差异过大说明哈希分布不好。

实操代码示例 #

public class DiceHashTest {
    public static void main(String[] args) {
        // 统计每个哈希码对应的实例数量
        Map<Integer, Integer> hashCounter = new HashMap<>();
        // 记录碰撞的哈希码和对应的实例
        Map<Integer, List<Dice>> collisionRecords = new HashMap<>();

        // 遍历所有可能的Dice实例
        for (int diceNum = 1; diceNum <= 10; diceNum++) {
            for (int sideNum = 1; sideNum <= 100; sideNum++) {
                Dice dice = new Dice(diceNum, sideNum);
                int hash = dice.hashCode();
                // 更新哈希计数
                hashCounter.put(hash, hashCounter.getOrDefault(hash, 0) + 1);
                // 记录碰撞实例
                collisionRecords.computeIfAbsent(hash, k -> new ArrayList<>()).add(dice);
            }
        }

        // 输出碰撞情况
        long collisionCount = hashCounter.values().stream().filter(count -> count > 1).count();
        System.out.println("出现碰撞的哈希码数量：" + collisionCount);
        if (collisionCount > 0) {
            collisionRecords.forEach((hash, diceList) -> {
                if (diceList.size() > 1) {
                    System.out.printf("哈希码%d对应%d个实例：%s%n", 
                        hash, diceList.size(), diceList.toString());
                }
            });
        }

        // 输出桶分布情况（假设桶数为16）
        int bucketNum = 16;
        Map<Integer, Integer> bucketCounter = new HashMap<>();
        for (Map.Entry<Integer, Integer> entry : hashCounter.entrySet()) {
            int bucket = entry.getKey() & (bucketNum - 1);
            bucketCounter.put(bucket, bucketCounter.getOrDefault(bucket, 0) + entry.getValue());
        }
        System.out.println("\n" + bucketNum + "个桶的分布情况：");
        bucketCounter.forEach((bucket, count) -> 
            System.out.printf("桶%d：%d个实例%n", bucket, count));
    }
}

运行这段代码，就能直观看到你的哈希函数表现如何。

内容的提问来源于stack exchange，提问作者Detinoy