About the implementation of Java HashMap

Question

Why the capacity must be a multiple or 2? Why use "&" in the indexFor functions? Why recompute the hash in the hash function instead of directly using the key's hash code?

I think there are some important differences between the this implementation and the description on the "Introduction to Algorithm".

What does ">>>" mean?

static int hash(int h) {
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
}

Can anyone give me some guide? I appreciate If some one can explain the hash algorithm. Thanks a lot!

Answer 1

This is a performance optimization. The usual way to map a hash code to a table index is

table_index = hash_code % table_length;

The % operator is expensive. If table_length is a power of 2, then the calculation:

table_index = hash_code & (table_length - 1);

is equivalent to the (much) more expensive modulo operation.

Answer 2

Pay no attention to the man behind the curtain.

The actual algorithm is no doubt a combination of "what feels good" to the developer, fixes for some odd degenerate cases, and simple tradition (for which users often develop obscure dependencies).

And note this:

 * Applies a supplemental hash function to a given hashCode, which * defends against poor quality hash functions. This is critical * because HashMap uses power-of-two length hash tables, that * otherwise encounter collisions for hashCodes that do not differ * in lower bits. Note: Null keys always map to hash 0, thus index 0.

Net: So long as it works and the performance is good, you don't care.