我有点惊讶的是 hashCode() 方法的速度似乎比下面的基准测试方法的简单重写慢50倍。
考虑一个基本的 Book 不重写的类 hashCode() :

public class Book {
private int id;
private String title;
private String author;
private Double price;

public Book(int id, String title, String author, Double price) {
    this.id = id;
    this.title = title;
    this.author = author;
    this.price = price;
}
}

或者，考虑另一个相同的问题 Book 班级， BookWithHash ，将覆盖 hashCode() 方法使用intellij的默认实现：

public class BookWithHash {
private int id;
private String title;
private String author;
private Double price;

public BookWithHash(int id, String title, String author, Double price) {
    this.id = id;
    this.title = title;
    this.author = author;
    this.price = price;
}

@Override
public boolean equals(final Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    final BookWithHash that = (BookWithHash) o;

    if (id != that.id) return false;
    if (title != null ? !title.equals(that.title) : that.title != null) return false;
    if (author != null ? !author.equals(that.author) : that.author != null) return false;
    return price != null ? price.equals(that.price) : that.price == null;
}

@Override
public int hashCode() {
    int result = id;
    result = 31 * result + (title != null ? title.hashCode() : 0);
    result = 31 * result + (author != null ? author.hashCode() : 0);
    result = 31 * result + (price != null ? price.hashCode() : 0);
    return result;
}
}

然后，以下jmh基准测试的结果向我建议 Object 类的实现比 hashCode() 在 BookWithHash 班级：

public class Main {

public static void main(String[] args) throws RunnerException {
    Options opt = new OptionsBuilder().include(Main.class.getSimpleName()).forks(1).build();
    new Runner(opt).run();
}

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public long bookWithHashKey() {
    long sum = 0L;
    for (int i = 0; i < 10_000; i++) {
        sum += (new BookWithHash(i, "Jane Eyre", "Charlotte Bronte", 14.99)).hashCode();
    }
    return sum;
}

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public long bookKey() {
    long sum = 0L;
    for (int i = 0; i < 10_000; i++) {
        sum += (new Book(i, "Jane Eyre", "Charlotte Bronte", 14.99)).hashCode();
    }
    return sum;
}
}

事实上，总结的结果表明 hashCode() 上 BookWithHash 类比调用快一个数量级 hashCode() 上 Book 类（请参见下面的完整jmh输出）：

我对此感到惊讶的原因是我理解默认值 Object.hashCode() 实现（通常）是对象的初始内存地址的散列，我希望它（至少对于内存查找）在微体系结构级别非常快。这些结果似乎向我暗示，内存位置的散列是内存中的瓶颈 Object.hashCode() ，与上面给出的简单覆盖相比。我会很感激其他人对我的理解以及是什么导致了这种令人惊讶的行为。
完整jmh输出：