Differences between hashtable and hashmap in C #-very detailed;

The difference between hashtable and hashmap in C #-For details, refer

Http://www.hd1204.com/article/html/1655.htmlthank you for your reference;

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 of the outstanding differences. Of course, there are still many different implementations, such as hashmap's operations on null.

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.

Hashtable inherits from the dictionary class, while hashmap is Java

Simple operations on Hash Tables
Add a keyValue key-value pair in the hash table: hashtableobject. Add (Key, value );
Remove a keyValue key-value pair in the hash table: hashtableobject. Remove (key );
Remove all elements from the hash table: hashtableobject. Clear ();
Determine whether the hash table contains the specified key: hashtableobject. Contains (key );
The following console contains all the preceding operations:

View code

Using system;
Using system. collections; this namespace must be introduced when file uses hashtable.
Class hashtable
{
Public static void main ()
{
Hashtable ht = new hashtable (); file to create a hashtable instance
Ht. Add (E, E); add a keyValue pair
Ht. Add (A, );
Ht. Add (C, C );
Ht. Add (B, B );

String S = (string) HT [a];
If (HT. Contains (E) file determines whether the hash table contains a specific key. The return value is true or false.
Console. writeline (the E keyexist );
Ht. Remove (c); remove a keyValue pair
Console. writeline (HT [a]); Output
Ht. Clear (); remove all elements
Console. writeline (HT [a]); file will not have any output here
}
}

// 3. traverse the hash table
// Dictionaryentry object is required to traverse the hash table. The Code is as follows:


For (dictionaryentry de in HT) fileht is a hashtable instance.
{
Console. writeline (De. Key); De. Key corresponds to the key
Console. writeline (De. Value); De. Key corresponds to the keyValue key-Value Pair Value
}

// 4. Sort the hash table
/* Sort the hash table. The definition here is to re-arrange the keys in the key-Value Pair according to certain rules, but in fact this definition cannot be implemented, because we cannot re-arrange keys directly in hashtable, if hashtable needs to provide output of certain rules, we can adopt a work und :*/


Arraylist akeys = new arraylist (HT. Keys); file do not forget to import system. Collections
Akeys. Sort (); files are sorted alphabetically.
For (string skey in akeys)
{
Console. Write (skey + );
Console. writeline (HT [skey]); output after sorting
}