为什么HashMap和Hastable方法有区别？

Question

I was wondering for put method difference in HashMap and Hashtable

HashTable put method code

Entry tab[] = table;
     int hash = key.hashCode();
     int index = (hash & 0x7FFFFFFF) % tab.length;
     for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
         if ((e.hash == hash) && e.key.equals(key)) {
             V old = e.value;
             e.value = value;
             return old;
         }
     }

HashMap put method code

int hash = hash(key.hashCode());
     int i = indexFor(hash, table.length);
     for (Entry<K,V> e = table[i]; e != null; e = e.next) {
         Object k;
         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
             V oldValue = e.value;
             e.value = value;
             e.recordAccess(this);
             return oldValue;
         }
     }

why hashtable has different code for finding index?

int index = (hash & 0x7FFFFFFF) % tab.length;

while hashMap has hash() function provided by jdk designers.

Answer 1

What is 0x7FFFFFFF in binary? It's 01111111111111111111111111111111 .

Note that the leftmost bit is 0 . That means that the number is always positive (Since the leftmost bit is zero). Because of the & , every number that'll be & -ed with this binary will be non-negative since:

01111111111111111111111111111111
Anything                          &
--------------------------------
0 ← Always

After this, the % operator is used to ensure that we are in the range of tab.length .

You didn't post the implementation of how HashMap generates the index. I don't think it's very different. After all they have a very similar logic.

HashMap calls indexFor which is doing: return h & (length-1);

Important note: HashTable is older than HashMap , it's no wonder that there are difference implementations.

Answer 2

HashTable:

int index = (hash & 0x7FFFFFFF) % tab.length;

which means: hash - without the leftmost bit (sign) modulo the table length

HashMap:

int i = indexFor(hash, table.length);

is calling:

static int indexFor(int h, int length) {
   return h & (length-1);
}

which means modulo length-1 not a big difference there, and actually modulo length-1 means that the maximum value we can get is length-2. Here, the length-1 assures that we won't run into a scenario we'll get 0xFFFFFFFF and actually the highest value we might get will be 0xFFFFFFFE .

The difference is in the lower bits (in HashMap vs. Higher bits in HashTable). And now we should ask (recursively) why is that. And the answer is hiding in the hash() method which appears in the first row of the code (above) and which also differs from the HashTable implementation:

int hash = hash(key.hashCode());

and the explanation is found in the hash() method :

           /**
  258      * Applies a supplemental hash function to a given hashCode, which
  259      * defends against poor quality hash functions.  This is critical
  260      * because HashMap uses power-of-two length hash tables, that
  261      * otherwise encounter collisions for hashCodes that do not differ
  262      * in lower bits. Note: Null keys always map to hash 0, thus index 0.
  263      */
  264     static int hash(int h) {
  265         // This function ensures that hashCodes that differ only by
  266         // constant multiples at each bit position have a bounded
  267         // number of collisions (approximately 8 at default load factor).
  268         h ^= (h >>> 20) ^ (h >>> 12);
  269         return h ^ (h >>> 7) ^ (h >>> 4);
  270     }
  271