The difference between hashmap and hashtable and the synchronous operation of hashmap

Differences between hashtable and hashmap
1. hashtable is a subclass of dictionary, and hashmap is an implementation class of the map interface;

2. Methods in hashtable are synchronized, while those in hashmap are not synchronized by default. That is to say, hashtable can be safely used in multi-threaded applications without special operations. For hashmap, additional synchronization mechanisms are required. However, the synchronization problem of hashmap can be solved through a static method of collections:
Map collections. synchronizedmap (MAP m)
This method returns a synchronous map, which encapsulates all the underlying hashmap methods, making the underlying hashmap safe even in a multi-threaded environment.

3. In hashmap, null can be used as a key, and there is only one such key. One or more keys can correspond to null values. When the get () method returns a null value, it can indicate that the key does not exist in hashmap or that the corresponding value of the key is null. Therefore, the get () method cannot be used to determine whether a key exists in the hashmap. Instead, the containskey () method should be used to determine whether a key exists in the hashmap.

4. The underlying implementation mechanism is different. The access speed of hashmap is faster than that of hashtable, because it does not need to perform synchronization tests. We recommend that you use hashmap instead of hashtable in a non-multithreading environment.

Differences between hashmap and hashtable
Hashtable is widely used. hashmap is a class used to replace hashtable in the new framework. In other words, hashmap is recommended instead of hashtable. Maybe you think hashtable is very useful. Why not? Here we will briefly analyze their differences.
1. The hashtable method is synchronous, And the hashmap is not synchronized. Therefore, the difference between manual synchronization of hashmap in multithreading is like that of vector and arraylist.

2. hashtable does not allow null values (neither key nor value). hashmap allows null values (both key and value ).

3. hashtable has a contains (object value), which has the same functions as containsvalue (object value.

4. hashtable uses enumeration and hashmap uses iterator.

The above is just a difference on the surface, and their implementation is also very different.

5. The default size of the hash array in hashtable is 11, and the increase is in the old * 2 + 1 mode. The default size of the hash array in hashmap is 16, and it must be an index of 2.

6. For different hash values, hashtable directly uses the hashcode of the object. The Code is as follows:
Int hash = key. hashcode ();
Int Index = (hash & 0x7fffffff) % tab. length;
Hashmap recalculates the hash value and replaces the modulo:
Int hash = hash (k );
Int I = indexfor (hash, table. Length );

Static int Hash (Object X ){
Int H = x. hashcode ();

H + = ~ (H <9 );
H ^ = (H >>> 14 );
H + = (H <4 );
H ^ = (H >>> 10 );
Return h;
}
Static int indexfor (int h, int length ){
Return H & (length-1 );
}
The above are just some outstanding differences. Of course, there are many differences in their implementation, such
Hashmap's null operation