Questions d'entrevue Java - Explication détaillée de la différence entre le hashmap et le hashtable

1. La différence entre le hashmap et le hashtable

Regardons d'abord la définition de deux classes

 Classe publique HashTable étend le dictionnaire implémente la carte, clonable, java.io.Serializable

 classe publique Hashmap étend AbstractMap implémente la carte, clonable, sérialisable

On peut voir que Hashtable hérite de Dictionary et Hashmap hérite d'AbstractMap

La méthode de put de hashtable est la suivante

 public synchronisé v put (key k, vale v) {// ########## Remarque Ici 1 // Assurez-vous que la valeur n'est pas null if (value == null) {// ####### Remarque ici 2 lancez new nullpointerException (); } // s'assure que la clé n'est pas déjà dans le hashtable. Onglet d'entrée [] = table; int hash = key.hashcode (); // ######## Remarque Ici 3 int index = (hash & 0x7fffffff)% tab.Length; pour (entrée e = tab [index]; e! = null; e = e.next) {if ((e.hash == hash) && e.key.equals (key)) {v old = e.Value; e.Value = valeur; retourne vieux; }} modCount ++; if (count> = threshold) {// rehash le tableau si le seuil est dépassé rehash (); tab = table; index = (hash & 0x7fffffff)% tab.length; } // Crée la nouvelle entrée. Entrée e = tab [index]; tab [index] = nouvelle entrée (hachage, clé, valeur, e); Count ++; retourner null; }

Remarque 1 La méthode est synchrone

Remarque 2 La méthode ne permet pas de valeur == null

Remarque 3 La méthode appelle la méthode HashCode de la clé. Si key == null, une exception de pointeur nul sera lancée. La méthode de put de Hashmap est la suivante.

 public v put (k key, v valeur) {// ########## Remarque ici 1 if (key == null) // ######## Remarque ici 2 return putFornullKey (valeur); int hash = hash (key.hashcode ()); int i = indexfor (hash, table.length); pour (entrée e = table [i]; e! = null; e = e.next) {objet k; if (e.hash == hash && ((k = e.key) == key || key.equals (k))) {v oldValue = e.Value; e.Value = valeur; e.recordAccess (this); Retour OldValue; }} modCount ++; Addentry (hachage, clé, valeur, i); // ######## Remarque ici Retour Null; }

Remarque 1 La méthode est asynchrone

Remarque 2 La méthode permet Key == null

Remarque 3 La méthode ne fait aucun appel à la valeur, il est donc autorisé à être nul.

Remplir:

Hashtable a une méthode contient, qui peut facilement provoquer des malentendus, il a donc été supprimé dans hashmap.

Bien sûr, les deux classes utilisent les méthodes CONTAINSKEY et CONTAINS VALALUE.

Hashmap est une implémentation légère de hashtable (implémentation sans thread-sate). Ils complètent tous l'interface de carte. La principale différence est que HashMap permet des clés nuls. En raison de la non-sécurité, il peut être plus efficace que le hashtable.

Hashmap permet Null comme clé ou valeur d'une entrée, tandis que le hashtable ne le fait pas.

Hashmap supprime la méthode contient la méthode et la modifie en contenant la valeur et contenantKey. Parce que la méthode contient est facile à provoquer des malentendus.

Hashtable hérite de la classe de dictionnaire, et HashMap est une implémentation de l'interface MAP introduite par Java 1.2.

La plus grande différence est que la méthode de hashtable est de synchroniser, tandis que le hashmap ne l'est pas. Lorsque plusieurs threads accèdent au hashtable, ils n'ont pas besoin de se synchroniser pour ses méthodes elles-mêmes, et HashMap doit fournir une synchronisation externe (Collection.SynchronizedMap).

Les algorithmes de hachage / rehash utilisés par le hashtable et le hashmap sont à peu près les mêmes, il n'y aura donc pas de grande différence de performance.

Résumer:

Les valeurs clés de Hashmap sont autorisées à être vides et sont asynchrones

La valeur clé dans le hashtable n'est pas autorisée à être nul et est synchronisée

L'héritage est différent, mais les deux implémentent l'interface de carte

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.