1. Hashtable est une sous-classe de Dictionary.
Copiez le code comme suit :
classe publique Hashtable<K,V>
étend le dictionnaire<K,V>
implémente Map<K,V>, Cloneable, java.io.Seriallessly
Carte de hachage :
Copiez le code comme suit :
classe publique HashMap<K,V>
étend AbstractMap<K,V>
implémente Map<K,V>, Cloneable, Serialisable
HashMap et Hashtable sont toutes deux des classes d'implémentation de l'interface Map ;
2. Les méthodes de Hashtable sont synchrones (), mais les méthodes de HashMap ne sont pas synchrones par défaut. Autrement dit, dans les applications multithread, Hashtable peut être utilisé en toute sécurité sans opérations spéciales ; pour HashMap, un mécanisme de synchronisation supplémentaire est requis. Mais le problème de synchronisation de HashMap peut être résolu grâce à une méthode statique de Collections :
Copiez le code comme suit :
public static <K,V> Map<K,V> synchroniséMap(Map<K,V> m)
Cette méthode renvoie une carte synchronisée, ce qui signifie que la carte renvoyée est thread-safe. Il convient de noter que lors d'une itération sur la carte renvoyée, vous devez synchroniser manuellement sur la carte renvoyée, sinon cela entraînera un comportement indéfini :
Copiez le code comme suit :
Carte m = Collections.synchronizedMap(new HashMap());
...
Set s = m.keySet(); // Pas besoin d'être dans un bloc synchronisé
...
synchronisé(m) { // Synchronisation sur m, pas sur s !
Itérateur i = s.iterator(); // Doit être dans un bloc synchronisé
tandis que (i.hasNext())
foo(i.next());
}
3. Dans HashMap, null peut être utilisé comme clé, et il n'existe qu'une seule clé de ce type ; il peut y avoir une ou plusieurs clés dont la valeur correspondante est nulle ; Lorsque la méthode get() renvoie une valeur nulle, cela peut signifier que la clé n'existe pas dans le HashMap, ou cela peut également signifier que la valeur correspondant à la clé est nulle. Par conséquent, dans HashMap, la méthode get() ne peut pas être utilisée pour déterminer si une certaine clé existe dans HashMap, mais la méthode containKey() doit être utilisée pour le déterminer. La valeur clé de Hashtable ne peut pas être nulle, sinon : java.lang.NullPointerException.
4.HashTable utilise l'énumération et HashMap utilise Iterator.
Les différences ci-dessus ne sont que superficielles et leurs mises en œuvre sont également très différentes.
5. La taille par défaut du tableau de hachage dans HashTable est de 11 et la méthode d'augmentation est old*2+1. La taille par défaut du tableau de hachage dans HashMap est de 16 et doit être un exposant de 2.
6. L'utilisation des valeurs de hachage est différente. HashTable utilise directement le hashCode de l'objet. Le code est le suivant :
Copiez le code comme suit :
int hash = key.hashCode();
int index = (hachage & 0x7FFFFFFFF) % tab.length;
HashMap recalcule la valeur de hachage et utilise AND au lieu du module, comme la méthode put de HashMap :
Copiez le code comme suit :
public V put (clé K, valeur V) {
si (clé == null)
return putForNullKey(valeur);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
pour (Entrée<K,V> e = table[i]; e != null; e = e.next) {
Objet k ;
if (e.hash == hachage && ((k = e.key) == clé || key.equals(k))) {
V oldValue = e.value ;
e.value = valeur ;
e.recordAccess(this);
retourner ancienneValeur ;
}
}
modCount++;
addEntry(hash, clé, valeur, i);
renvoie null ;
}
Copiez le code comme suit :
hachage int statique (int h) {
// Cette fonction garantit que les hashCodes qui diffèrent uniquement par
// les multiples constants à chaque position de bit ont une limite
// nombre de collisions (environ 8 au facteur de charge par défaut).
h ^= (h >>> 20) ^ (h >>> 12);
retourner h ^ (h >>> 7) ^ (h >>> 4);
}
Copiez le code comme suit :
static int indexFor (int h, int longueur) {
retourner h & (longueur-1);
}
