java - 为什么 ChronicleMap 不使用 hashCode 或 equals 来查找键？

Question

import net.openhft.chronicle.map.ChronicleMap;

import java.io.File;
import java.io.Serializable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class App {

    public static void main(String[] args) throws Exception  {

        Map<Point, Point> map1 = new ConcurrentHashMap<>();

        ChronicleMap<Point, Point> map2 = ChronicleMap
                .of(Point.class, Point.class)
                .name("map")
                .averageKey(new Point(10, 10))
                .averageValue(new Point(10, 10))
                .entries(50)
                .createPersistedTo(new File("c:/temp/map/param.dat"));

        Point key = new Point(12, 12);
        key.hashCode();

        map1.put(key, key);
        map2.put(key, key);

        System.out.println("ConcurrentHashMap.get returned " + map1.get(new Point(12, 12)));
        System.out.println("ChronicleMap.get returned " + map2.get(new Point(12, 12)));
    }
}

class Point implements Serializable {
    private int x = 0;
    private int y = 0;
    private int _hash = 0;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }


    @Override
    public String toString() {
        return super.toString() +  " {" + x + "," + y + "}";
    }

    @Override
    public int hashCode() {
        _hash = 1;
        _hash = _hash * 17 + x;
        _hash = _hash * 31 + y;
        return _hash;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof  Point) {
            return (x == ((Point) obj).getX()) && (y == ((Point) obj).getY());
        }
        return false;
    }
}

正如您在上面的示例中看到的，ChronicleMap 的行为与 ConcurrentHashMap(与 HashMap 相同)有点不同，因为它无法查找具有 hashCode 或 equals 的键。

有人能指出可以采取什么措施来解决这个问题吗？

更新；执行时，程序将返回以下结果:

ConcurrentHashMap.get returned App.Point@38f {12,12}
ChronicleMap.get returned null

Answer 1

ChronicleMap 序列化 key 并采用字节的 64 位哈希值。

使用 64 位散列，因为映射是为大量键设计的，例如。数十亿个，而当您拥有数百万个 key 时，32 位哈希往往会产生很高的冲突率。

它还可以使用更高级的哈希策略，例如 https://github.com/OpenHFT/Zero-Allocation-Hashing

注意:使用 Serialized 是执行此操作效率最低的方法，但对于本例来说，越少越好。