Différences entre HashMap et Hashtable ?

https://stackoverflow.com/questions/40471

09-06-2019
|

Question

Quelles sont les différences entre un HashMap et un Hashtable en Java ?

Qu’est-ce qui est le plus efficace pour les applications non threadées ?

La solution

Il existe plusieurs différences entre HashMap et Hashtable en Java :

Hashtable est synchronisé, alors que HashMap n'est pas.Cela fait HashMap mieux pour les applications non threadées, car les objets non synchronisés fonctionnent généralement mieux que les objets synchronisés.
Hashtable ne permet pas de null clés ou valeurs. HashMap permet à un null clé et un nombre quelconque de null valeurs.
L'une des sous-classes de HashMap est LinkedHashMap, donc dans le cas où vous souhaiteriez un ordre d'itération prévisible (qui est l'ordre d'insertion par défaut), vous pouvez facilement échanger le HashMap pour un LinkedHashMap.Ce ne serait pas aussi simple si vous utilisiez Hashtable.

Puisque la synchronisation n'est pas un problème pour vous, je vous recommande HashMap.Si la synchronisation devient un problème, vous pouvez également consulter ConcurrentHashMap.

Autres conseils

Notez que de nombreuses réponses indiquent que Hashtable est synchronisé. En pratique, cela ne vous rapporte que très peu. La synchronisation se fait sur les méthodes accesseur/mutateur qui empêcheront deux threads d'ajouter ou de supprimer simultanément de la carte, mais dans le monde réel, vous aurez souvent besoin d'une synchronisation supplémentaire.

Un idiome très courant est de « vérifier puis mettre » — c'est-à-direcherchez une entrée dans le Map, et ajoutez-le s'il n'existe pas déjà.Il ne s’agit en aucun cas d’une opération atomique, que vous utilisiez Hashtable ou HashMap.

Une synchronisation équivalente HashMap peut être obtenu par :

Collections.synchronizedMap(myMap);

Mais pour mettre en œuvre correctement cette logique, vous avez besoin synchronisation supplémentaire de la forme:

synchronized(myMap) {
    if (!myMap.containsKey("tomato"))
        myMap.put("tomato", "red");
}

Même en itérant sur un Hashtableles entrées de (ou un HashMap obtenu par Collections.synchronizedMap) n'est pas thread-safe à moins que vous ne gardiez également le Map d'être modifié par une synchronisation supplémentaire.

Implémentations du ConcurrentMap interface (par exemple ConcurrentHashMap) résolvez une partie de ce problème en incluant sémantique de vérification puis d'action thread-safe tel que:

ConcurrentMap.putIfAbsent(key, value);

Hashtable est considéré comme du code hérité.Il n'y a rien à propos Hashtable cela ne peut pas être fait en utilisant HashMap ou des dérivations de HashMap, donc pour le nouveau code, je ne vois aucune justification pour revenir à Hashtable.

Cette question est souvent posée lors d'un entretien pour vérifier si le candidat comprend l'utilisation correcte des classes de collecte et connaît les solutions alternatives disponibles.

La classe HashMap est à peu près équivalente à Hashtable, sauf qu'elle n'est pas synchronisée et autorise les valeurs NULL.(HashMap autorise les valeurs nulles comme clé et valeur alors que Hashtable n'autorise pas les valeurs nulles).
HashMap ne garantit pas que l'ordre de la carte restera constant dans le temps.
HashMap n'est pas synchronisé alors que Hashtable est synchronisé.
L'itérateur du HashMap est sécurisé, contrairement à l'énumérateur de la table de hachage, et lève une exception ConcurrentModificationException si un autre thread modifie structurellement la carte en ajoutant ou en supprimant un élément à l'exception de la méthode Remove() de l'itérateur.Mais ce n'est pas un comportement garanti et sera fait par JVM dans la mesure du possible.

Remarque sur certains termes importants

Synchronisé signifie qu'un seul thread peut modifier une table de hachage à un moment donné.Fondamentalement, cela signifie que tout thread avant d'effectuer une mise à jour sur une table de hachage devra acquérir un verrou sur l'objet tandis que d'autres attendront que le verrou soit libéré.
La sécurité intégrée est pertinente dans le contexte des itérateurs.Si un itérateur a été créé sur un objet de collection et qu'un autre thread tente de modifier "structurellement" l'objet de collection, une exception de modification simultanée sera levée.Il est cependant possible pour d'autres threads d'invoquer la méthode "set" car elle ne modifie pas "structurellement" la collection.Cependant, si avant d'appeler « set », la collection a été structurellement modifiée, « IllegalArgumentException » sera levée.
La modification structurelle signifie la suppression ou l'insertion d'un élément qui pourrait effectivement modifier la structure de la carte.

HashMap peut être synchronisé par

Map m = Collections.synchronizeMap(hashMap);

MAP offre des vues de collecte au lieu de la prise en charge directe de l'itération via des objets d'énumération.Les vues de collecte améliorent considérablement l'expressivité de l'interface, comme discuté plus loin dans cette section.Map vous permet de parcourir des clés, des valeurs ou des paires clé-valeur ;Hashtable ne propose pas la troisième option.La carte offre un moyen sûr de supprimer les entrées au milieu de l'itération;Hashtable ne l'a pas fait.Enfin, Map corrige une lacune mineure dans l'interface Hashtable.HashTable a une méthode appelée Contise, qui renvoie True si le hashtable contient une valeur donnée.Compte tenu de son nom, vous vous attendez à ce que cette méthode renvoie True si le hashtable contenait une clé donnée, car la clé est le mécanisme d'accès principal pour un hashtable.L'interface MAP élimine cette source de confusion en renommant la méthode contient une valeur.En outre, cela améliore la cohérence de l'interface - contient des parallèles VALALUE CONTOURSKEY.

L'interface cartographique

HashMap:Une mise en œuvre du Map interface qui utilise des codes de hachage pour indexer un tableau.Hashtable:Bonjour, j'ai appelé en 1998.Ils veulent récupérer leur API de collections.

Sérieusement, tu ferais mieux de rester à l'écart Hashtable tout à fait.Pour les applications monothread, vous n'avez pas besoin de la surcharge supplémentaire de synchronisation.Pour les applications hautement concurrentes, la synchronisation paranoïaque peut entraîner une famine, des blocages ou des pauses inutiles dans le garbage collection.Comme Tim Howland l'a souligné, vous pouvez utiliser ConcurrentHashMap plutôt.

Garde en tête que HashTable était une classe héritée avant l'introduction de Java Collections Framework (JCF) et a ensuite été modernisée pour implémenter le Map interface.Ainsi était Vector et Stack.

Par conséquent, restez toujours à l’écart d’eux dans le nouveau code car il existe toujours une meilleure alternative dans le JCF. comme d'autres l'ont souligné.

Voici la Aide-mémoire de la collection Java que vous trouverez utile.Notez que le bloc gris contient les classes héritées HashTable, Vector et Stack.

enter image description here

En plus de ce qu'izb a dit, HashMap autorise les valeurs nulles, alors que le Hashtable ne fait pas.

Notez également que Hashtable prolonge le Dictionary classe, qui, comme le Javadocs état, est obsolète et a été remplacé par le Map interface.

Il existe de nombreuses bonnes réponses déjà publiées.J'ajoute quelques nouveaux points et je le résume.

HashMap et Hashtable les deux sont utilisés pour stocker données sous forme de clé et de valeur.Les deux utilisent une technique de hachage pour stocker des clés uniques.Mais il existe de nombreuses différences entre les classes HashMap et Hashtable, indiquées ci-dessous.

Carte de hachage

HashMap n'est pas synchronisé.Il n’est pas thread-safe et ne peut pas être partagé entre plusieurs threads sans code de synchronisation approprié.
HashMap autorise une clé nulle et plusieurs valeurs nulles.
HashMap est une nouvelle classe introduite dans JDK 1.2.
HashMap est rapide.
Nous pouvons faire le HashMap comme synchronisé en appelant ce code
Map m = Collections.synchronizedMap(HashMap);
HashMap est parcouru par Iterator.
Itérateur dans HashMap est un échec rapide.
HashMap hérite de la classe AbstractMap.

Table de hachage

Hashtable est synchronisé.Il est thread-safe et peut être partagé avec de nombreux threads.
Hashtable n'autorise aucune clé ou valeur nulle.
Hashtable est une classe héritée.
Hashtable est lent.
Hashtable est synchronisé en interne et ne peut pas être désynchronisé.
Hashtable est parcouru par Enumerator et Iterator.
Recenseur dans Hashtable n'est pas infaillible.
Hashtable hérite de la classe Dictionary.

Lectures complémentaires Quelle est la différence entre HashMap et Hashtable en Java ?

Jetez un œil à ce tableau.Il fournit des comparaisons entre différentes structures de données ainsi que HashMap et Hashtable.La comparaison est précise, claire et facile à comprendre.

Matrice de collecte Java

Hashtable est semblable au HashMap et a une interface similaire.Il est recommandé d'utiliser HashMap, sauf si vous avez besoin de prise en charge d'applications existantes ou si vous avez besoin d'une synchronisation, comme le Hashtables les méthodes sont synchronisées.Donc dans votre cas comme vous n'êtes pas multi-thread, HashMaps sont votre meilleur pari.

Une autre différence clé entre hashtable et hashmap est que l'itérateur du HashMap est rapide alors que l'énumérateur de la table de hachage ne l'est pas et lance ConcurrentModificationException si un autre thread modifie structurellement la carte en ajoutant ou en supprimant un élément à l'exception de la propre méthode remove() de l'itérateur.Mais ce n'est pas un comportement garanti et sera fait par JVM dans la mesure du possible."

Ma source : http://javarevisited.blogspot.com/2010/10/difference-between-hashmap-and.html

Outre tous les autres aspects importants déjà mentionnés ici, l'API Collections (par ex.L'interface cartographique) est constamment modifiée pour se conformer aux "derniers et meilleurs" ajouts aux spécifications Java.

Par exemple, comparez l'itération de Java 5 Map :

for (Elem elem : map.keys()) {
  elem.doSth();
}

par rapport à l'ancienne approche Hashtable :

for (Enumeration en = htable.keys(); en.hasMoreElements(); ) {
  Elem elem = (Elem) en.nextElement();
  elem.doSth();
}

Dans Java 1.8, on nous promet également de pouvoir construire et accéder à des HashMaps comme dans les bons vieux langages de script :

Map<String,Integer> map = { "orange" : 12, "apples" : 15 };
map["apples"];

Mise à jour: Non, ils n'atterriront pas dans la 1.8...:(

Les améliorations de la collection de Project Coin seront-elles dans le JDK8 ?

Table de hachage est synchronisé, si vous l'utilisez dans un seul thread, vous pouvez utiliser Carte de hachage, qui est une version non synchronisée.Les objets non synchronisés sont souvent un peu plus performants.À propos, si plusieurs threads accèdent simultanément à une HashMap et qu'au moins un des threads modifie structurellement la carte, elle doit être synchronisée en externe.Vous pouvez envelopper une carte non synchronisée dans une carte synchronisée en utilisant :
```
Map m = Collections.synchronizedMap(new HashMap(...));
```
HashTable ne peut contenir qu'un objet non nul en tant que clé ou en tant que valeur.HashMap peut contenir une clé nulle et des valeurs nulles.
Les itérateurs renvoyés par Map sont rapides, si la carte est structurellement modifiée à tout moment après la création de l'itérateur, de quelque manière que ce soit sauf via la propre méthode Remove de l'itérateur, l'itérateur lancera un ConcurrentModificationException.Ainsi, face à des modifications concurrentes, l’itérateur échoue rapidement et proprement, plutôt que de risquer un comportement arbitraire et non déterministe à un moment indéterminé dans le futur. Alors que les énumérations renvoyées par les méthodes clés et éléments de Hashtable ne sont pas rapides.
HashTable et HashMap sont membres du Cadre de collections Java (depuis la plateforme Java 2 v1.2, HashTable a été mis à niveau pour implémenter l'interface Map).
HashTable est considéré comme du code hérité, la documentation conseille d'utiliser ConcurrentHashMap à la place de Hashtable si une implémentation hautement concurrente thread-safe est souhaitée.
HashMap ne garantit pas l'ordre dans lequel les éléments sont renvoyés.Pour HashTable, je suppose que c'est la même chose mais je ne suis pas entièrement sûr, je ne trouve pas de ressource qui l'indique clairement.

HashMap et Hashtable présentent également des différences algorithmiques significatives.Personne n'en a parlé auparavant, c'est pourquoi j'en parle. HashMap construira une table de hachage avec une puissance de deux tailles, l'augmentera dynamiquement de telle sorte que vous ayez au plus environ huit éléments (collisions) dans n'importe quel compartiment et mélangera très bien les éléments pour les types d'éléments généraux.Cependant, le Hashtable l'implémentation offre un contrôle meilleur et plus fin sur le hachage si vous savez ce que vous faites, à savoir que vous pouvez corriger la taille de la table en utilisant par exemple.le nombre premier le plus proche de la taille de votre domaine de valeurs, ce qui entraînera de meilleures performances que HashMap, c'est-à-diremoins de collisions dans certains cas.

Indépendamment des différences évidentes discutées en détail dans cette question, je vois la Hashtable comme une voiture à « conduite manuelle » où vous avez un meilleur contrôle sur le hachage et la HashMap comme la contrepartie « à conduite automatique » qui fonctionnera généralement bien.

Hashtable est synchronisé, contrairement à HashMap.Cela rend Hashtable plus lent que Hashmap.

Pour les applications non threadées, utilisez HashMap car elles sont par ailleurs identiques en termes de fonctionnalités.

Basé sur les informations ici, je recommanderais d'utiliser HashMap.Je pense que le plus grand avantage est que Java vous empêchera de le modifier pendant que vous le parcourez, à moins que vous ne le fassiez via l'itérateur.

UN Collection – parfois appelé conteneur – est simplement un objet qui regroupe plusieurs éléments en une seule unité. CollectionLes s sont utilisés pour stocker, récupérer, manipuler et communiquer des données agrégées.Un cadre de collections ^W est une architecture unifiée pour représenter et manipuler les collections.

Le HashMap ^JDK1.2 et table de hachage ^JDK1.0, les deux sont utilisés pour représenter un groupe d'objets représentés dans <Key, Value> paire.Chaque <Key, Value> la paire est appelée Entry objet.La collection d'entrées est référencée par l'objet de HashMap et Hashtable.Les clés d'une collection doivent être uniques ou distinctives.[car ils sont utilisés pour récupérer une valeur mappée sur une clé particulière.les valeurs d'une collection peuvent être dupliquées.]

« Membre de Superclass, Legacy et Collection Framework

Hashtable est une classe héritée introduite dans JDK1.0, qui est une sous-classe de la classe Dictionary.Depuis JDK1.2 Hashtable est repensé pour implémenter le Interface cartographique pour devenir membre du cadre de collection.HashMap est membre de Java Collection Framework dès le début de son introduction dans JDK1.2.HashMap est la sous-classe de la classe AbstractMap.

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable { ... }

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { ... }

« Capacité initiale et facteur de charge

La capacité est le nombre de compartiments dans la table de hachage, et la capacité initiale est simplement la capacité au moment où la table de hachage est créée.Notez que la table de hachage est ouverte :dans le cas d'un "hashcollision", un seul compartiment stocke plusieurs entrées, qui doivent être recherchées séquentiellement.Le facteur de charge est une mesure du niveau de remplissage de la table de hachage avant que sa capacité ne soit automatiquement augmentée.

HashMap construit une table de hachage vide avec la capacité initiale par défaut (16) et le facteur de charge par défaut (0,75).Alors que Hashtable construit une table de hachage vide avec une capacité initiale par défaut (11) et facteur de charge/rapport de remplissage (0,75).

« Modification structurelle en cas de collision de hachage

HashMap, Hashtable en cas de collisions de hachage, ils stockent les entrées de carte dans des listes chaînées. Depuis Java8 pour HashMap si le compartiment de hachage dépasse un certain seuil, ce compartiment passera de linked list of entries to a balanced tree.qui améliorent les performances dans le pire des cas de O(n) à O(log n).Lors de la conversion de la liste en arbre binaire, le hashcode est utilisé comme variable de branchement.S'il y a deux hashcodes différents dans le même bucket, l'un est considéré comme plus grand et va à droite de l'arborescence et l'autre à gauche.Mais lorsque les deux hashcodes sont égaux, HashMap suppose que les clés sont comparables et compare la clé pour déterminer la direction afin qu'un certain ordre puisse être maintenu.C'est une bonne pratique de créer les clés de HashMap comparable.Lors de l'ajout d'entrées si la taille du bucket atteint TREEIFY_THRESHOLD = 8 convertir la liste chaînée d'entrées en un arbre équilibré, en supprimant les entrées inférieures à TREEIFY_THRESHOLD et tout au plus UNTREEIFY_THRESHOLD = 6 reconvertira l'arborescence équilibrée en liste chaînée d'entrées. ^{Java 8 SRC, poteau de pile}

« Itération de vue de collection, Fail-Fast et Fail-Safe

    +--------------------+-----------+-------------+
    |                    | Iterator  | Enumeration |
    +--------------------+-----------+-------------+
    | Hashtable          | fail-fast |    safe     |
    +--------------------+-----------+-------------+
    | HashMap            | fail-fast | fail-fast   |
    +--------------------+-----------+-------------+
    | ConcurrentHashMap  |   safe    |   safe      |
    +--------------------+-----------+-------------+

Iterator est un échec rapide par nature.c'est-à-dire qu'il lève ConcurrentModificationException si une collection est modifiée lors d'une itération autre que sa propre méthode Remove().Alors que Enumeration est de nature à sécurité intégrée.Il ne génère aucune exception si une collection est modifiée lors d’une itération.

Selon Java API Docs, Iterator est toujours préféré à Enumeration.

_{NOTE: La fonctionnalité de l’interface Enumeration est dupliquée par l’interface Iterator.De plus, Iterator ajoute une opération de suppression facultative et a des noms de méthode plus courts.Les nouvelles implémentations devraient envisager d’utiliser Iterator plutôt que Enumeration.}

Dans Java 5 a introduit l'interface ConcurrentMap: ConcurrentHashMap - un système hautement concurrent et performant ConcurrentMap implémentation soutenue par une table de hachage.Cette implémentation ne bloque jamais lors des récupérations et permet au client de sélectionner le niveau de concurrence pour les mises à jour.Il est destiné à remplacer directement Hashtable:en plus de mettre en œuvre ConcurrentMap, il supporte toutes les méthodes « héritées » propres à Hashtable.

Chaque HashMapEntryla valeur est volatil garantissant ainsi une cohérence de grain fin pour les modifications contestées et les lectures ultérieures ;chaque lecture reflète la mise à jour la plus récente
Les itérateurs et les énumérations sont à sécurité intégrée - reflétant l'état à un moment donné depuis la création de l'itérateur/de l'énumération ;cela permet des lectures et des modifications simultanées au prix d'une cohérence réduite.Ils ne lancent pas ConcurrentModificationException.Cependant, les itérateurs sont conçus pour être utilisés par un seul thread à la fois.
Comme Hashtable mais contrairement à HashMap, cette classe ne permet pas d'utiliser null comme clé ou valeur.

public static void main(String[] args) {

    //HashMap<String, Integer> hash = new HashMap<String, Integer>();
    Hashtable<String, Integer> hash = new Hashtable<String, Integer>();
    //ConcurrentHashMap<String, Integer> hash = new ConcurrentHashMap<>();

    new Thread() {
        @Override public void run() {
            try {
                for (int i = 10; i < 20; i++) {
                    sleepThread(1);
                    System.out.println("T1 :- Key"+i);
                    hash.put("Key"+i, i);
                }
                System.out.println( System.identityHashCode( hash ) );
            } catch ( Exception e ) {
                e.printStackTrace();
            }
        }
    }.start();
    new Thread() {
        @Override public void run() {
            try {
                sleepThread(5);
                // ConcurrentHashMap  traverse using Iterator, Enumeration is Fail-Safe.

                // Hashtable traverse using Enumeration is Fail-Safe, Iterator is Fail-Fast.
                for (Enumeration<String> e = hash.keys(); e.hasMoreElements(); ) {
                    sleepThread(1);
                    System.out.println("T2 : "+ e.nextElement());
                }

                // HashMap traverse using Iterator, Enumeration is Fail-Fast.
                /*
                for (Iterator< Entry<String, Integer> > it = hash.entrySet().iterator(); it.hasNext(); ) {
                    sleepThread(1);
                    System.out.println("T2 : "+ it.next());
                    // ConcurrentModificationException at java.util.Hashtable$Enumerator.next
                }
                */

                /*
                Set< Entry<String, Integer> > entrySet = hash.entrySet();
                Iterator< Entry<String, Integer> > it = entrySet.iterator();
                Enumeration<Entry<String, Integer>> entryEnumeration = Collections.enumeration( entrySet );
                while( entryEnumeration.hasMoreElements() ) {
                    sleepThread(1);
                    Entry<String, Integer> nextElement = entryEnumeration.nextElement();
                    System.out.println("T2 : "+ nextElement.getKey() +" : "+ nextElement.getValue() );
                    //java.util.ConcurrentModificationException at java.util.HashMap$HashIterator.nextNode
                    //                                          at java.util.HashMap$EntryIterator.next
                    //                                          at java.util.Collections$3.nextElement
                }
                */
            } catch ( Exception e ) {
                e.printStackTrace();
            }
        }
    }.start();

    Map<String, String> unmodifiableMap = Collections.unmodifiableMap( map );
    try {
        unmodifiableMap.put("key4", "unmodifiableMap");
    } catch (java.lang.UnsupportedOperationException e) {
        System.err.println("UnsupportedOperationException : "+ e.getMessage() );
    }
}
static void sleepThread( int sec ) {
    try {
        Thread.sleep( 1000 * sec );
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

« Clés nulles et valeurs nulles

HashMap autorise au maximum une clé nulle et un nombre quelconque de valeurs nulles.Alors que Hashtable n'autorise même pas une seule clé nulle et une seule valeur nulle, si la clé ou la valeur est nulle, elle lève NullPointerException. ^Exemple

« Synchronisé, Thread Safe

Hashtable est synchronisé en interne.Son utilisation est donc très sûre Hashtable dans les applications multithread.Alors que HashMap n’est pas synchronisé en interne.Il n’est donc pas sécuritaire d’utiliser HashMap dans les applications multithread sans synchronisation externe.Vous pouvez synchroniser en externe HashMap en utilisant Collections.synchronizedMap() méthode.

« Performance

Comme Hashtable est synchronisé en interne, cela rend Hashtable légèrement plus lent que le HashMap.

@Voir

Pour les applications threadées, vous pouvez souvent vous en sortir avec ConcurrentHashMap – cela dépend de vos exigences de performances.

1.Hashmap et HashTable stocke à la fois la clé et la valeur.

2.Hashmap peut stocker une clé comme null. Hashtable je ne peux pas stocker null.

3.HashMap n'est pas synchronisé mais Hashtable est synchronisé.

4.HashMap peut être synchronisé avec Collection.SyncronizedMap(map)

Map hashmap = new HashMap();

Map map = Collections.SyncronizedMap(hashmap);

Outre les différences déjà évoquées, il convient de noter que depuis Java 8, HashMap remplace dynamiquement les nœuds (liste chaînée) utilisés dans chaque compartiment par des TreeNodes (arbre rouge-noir), de sorte que même en cas de collisions de hachage élevées, le pire des cas lors de la recherche est

O(log(n)) pour HashMap Contre Dans Hashtable.

*L'amélioration susmentionnée n'a pas été appliquée à Hashtable encore, mais seulement pour HashMap, LinkedHashMap, et ConcurrentHashMap.

Pour information, actuellement,

TREEIFY_THRESHOLD = 8 :si un bucket contient plus de 8 nœuds, la liste chaînée est transformée en arbre équilibré.
UNTREEIFY_THRESHOLD = 6 :lorsqu'un compartiment devient trop petit (en raison d'une suppression ou d'un redimensionnement), l'arborescence est reconvertie en liste chaînée.

Il existe 5 différenciations fondamentales avec HashTable et HashMaps.

Maps vous permet également d'itérer et de récupérer des clés, des valeurs et les deux paires clé-valeur, là où HashTable n'a pas toutes ces fonctionnalités.
Dans Hashtable, il existe une fonction contain(), qui est très déroutante à utiliser.Parce que la signification de contain est légèrement différente.Que cela signifie contient une clé ou contient une valeur ?difficile à comprendre.Même chose dans Maps, nous avons les fonctions ContainsKey() et ContainsValue(), qui sont très faciles à comprendre.
Dans hashmap, vous pouvez supprimer un élément lors d'une itération, en toute sécurité.alors que ce n'est pas possible dans les tables de hachage.
Les HashTables sont synchronisées par défaut, elles peuvent donc être utilisées facilement avec plusieurs threads.Alors que les HashMaps ne sont pas synchronisés par défaut, ils ne peuvent donc être utilisés qu'avec un seul thread.Mais vous pouvez toujours convertir HashMap en synchronisé en utilisant la fonction synchroniséMap(Map m) de la classe Collections util.
HashTable n'autorisera pas les clés nulles ou les valeurs nulles.Alors que HashMap autorise une clé nulle et plusieurs valeurs nulles.

Ma petite contribution :

Première et plus significative différence entre Hashtable et HashMap est-ce, HashMap n'est pas thread-safe alors que Hashtable est une collection thread-safe.

Deuxième différence importante entre Hashtable et HashMap est la performance, puisque HashMap n'est pas synchronisé, il fonctionne mieux que Hashtable.

Troisième différence sur Hashtable contre HashMap est-ce Hashtable est une classe obsolète et vous devriez utiliser ConcurrentHashMap au lieu de Hashtable en Java.

Table de hachage est une classe héritée du jdk qui ne devrait plus être utilisée.Remplacez-en les usages par ConcurrentHashMap.Si vous n'avez pas besoin de sécurité des threads, utilisez Carte de hachage ce qui n'est pas thread-safe mais plus rapide et utilise moins de mémoire.

1) La table de hachage est synchronisée alors que la table de hachage ne l'est pas.2) Une autre différence est que l'itérateur du HashMap est sécurisé, alors que l'énumérateur de la Hashtable ne l'est pas.Si vous modifiez la carte lors d'une itération, vous le saurez.

3) HashMap autorise les valeurs nulles, contrairement à Hashtable.

HashMap et HashTable

Quelques points importants sur HashMap et HashTable.veuillez lire les détails ci-dessous.

1) HashTable et Hashmap Implémentez l'interface java.util.map 2) HashMap et HashTable est la collection basée sur le hachage.et travailler sur le hachage.ce sont donc des similitudes entre HashMap et HashTable.

Quelle est la différence entre HashMap et HashTable ?

1) La première différence est que HashMap n'est pas thread-safe alors que HashTable est ThreadSafe
2) HashMap est meilleur en termes de performances car il n’est pas thread-safe.tandis que les performances de Hashtable ne sont pas meilleures car elles sont thread-safe.donc plusieurs threads ne peuvent pas accéder à Hashtable en même temps.

Carte de hachage :Il s'agit d'une classe disponible dans le package java.util et elle est utilisée pour stocker l'élément au format clé et valeur.

Table de hachage :Il s'agit d'une classe héritée qui est reconnue dans le cadre de la collection.

Hashtable:

Table de hachage est une structure de données qui conserve les valeurs de la paire clé-valeur.Il n’autorise pas null à la fois pour les clés et les valeurs.Vous obtiendrez un NullPointerException si vous ajoutez une valeur nulle.Il est synchronisé.Cela a donc son coût.Un seul fil peut accéder Table de hachage à un moment donné.

Exemple :

import java.util.Map;
import java.util.Hashtable;

public class TestClass {

    public static void main(String args[ ]) {
    Map<Integer,String> states= new Hashtable<Integer,String>();
    states.put(1, "INDIA");
    states.put(2, "USA");

    states.put(3, null);    //will throw NullPointerEcxeption at runtime

    System.out.println(states.get(1));
    System.out.println(states.get(2));
//  System.out.println(states.get(3));

    }
}

Carte de hachage :

Carte de hachage est comme Table de hachage mais il accepte également la paire clé-valeur.Il autorise null à la fois pour les clés et les valeurs.Sa performance meilleure est meilleure que HashTable, parce que c'est unsynchronized.

Exemple:

import java.util.HashMap;
import java.util.Map;

public class TestClass {

    public static void main(String args[ ]) {
    Map<Integer,String> states = new HashMap<Integer,String>();
    states.put(1, "INDIA");
    states.put(2, "USA");

    states.put(3, null);    // Okay
    states.put(null,"UK");

    System.out.println(states.get(1));
    System.out.println(states.get(2));
    System.out.println(states.get(3));

    }
}

HashMaps vous offre la liberté de synchronisation et le débogage est beaucoup plus facile

HashMap est émulé et donc utilisable dans GWT client code alors que Hashtable n'est pas.

Synchronisation ou Thread Safe :

Hash Map n'est pas synchronisé, il n'est donc pas sécurisé et il ne peut pas être partagé entre plusieurs threads sans bloc synchronisé approprié, tandis que Hashtable est synchronisé et est donc thread-safe.

Clés nulles et valeurs nulles :

HashMap autorise une clé nulle et n'importe quel nombre de valeurs nulles. Hashtable n'autorise pas les clés ou valeurs nulles.

Itérer les valeurs:

L'itérateur dans HashMap est un itérateur à échec rapide alors que l'énumérateur de la table de hachage ne l'est pas et lève ConcurrentModificationException si un autre thread modifie structurellement la carte en ajoutant ou en supprimant un élément à l'exception de la propre méthode Remove () de l'itérateur.

Superclasse et héritage :

HashMap est une sous-classe de la classe AbstractMap tandis que Hashtable est une sous-classe de la classe Dictionary.

Performance :

Comme HashMap n'est pas synchronisé, il est plus rapide que Hashtable.

Référer http://modernpathshala.com/Article/1020/difference-between-hashmap-and-hashtable-in-java pour des exemples, des questions d'entretien et des quiz liés à la collection Java

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow