Différences entre HashMap et Hashtable?

Notez que beaucoup de réponses indiquent que Hashtable est synchronisé. En pratique, cela vous achète très peu. La synchronisation est sur les méthodes accessor / mutator arrêtera deux threads ajoutant ou supprimant de la carte simultanément, mais dans le monde réel, vous aurez souvent besoin d'une synchronisation supplémentaire.

Un idiome très commun est de "vérifier puis mettre" - c'est-à-dire rechercher une entrée dans la Carte, et l'ajouter si elle n'existe pas déjà. Ce n'est en aucun cas une opération atomique que vous utilisiez Hashtable ou HashMap.

Une HashMap synchronisée de manière équivalente peut être obtenue par:

Collections.synchronizedMap(myMap);

Mais pour implémenter correctement cette logique, vous avez besoin de synchronisation supplémentaire {[5] } de la forme:

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

Même en itérant sur les entrées d'une table de hachage (ou une HashMap obtenue par les Collections.synchronizedMap) n'est pas thread safe sauf si vous empêchez également la carte d'être modifiée via une synchronisation supplémentaire.

Implémentations de la ConcurrentMap interface (par exemple ConcurrentHashMap) résoudre certains de ce en incluant thread-safe check-puis-loi sur la sémantique exemple:

ConcurrentMap.putIfAbsent(key, value);

Hashtable est considéré comme du code hérité. Il n'y a rien à propos de Hashtable qui ne puisse ê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 en entrevue pour vérifier si le candidat comprend l'utilisation correcte des classes de collecte et est au courant des solutions alternatives disponibles.

1. La classe HashMap est à peu près équivalente à Hashtable, sauf qu'elle n'est pas synchronisée et autorise les valeurs nulles. (HashMap autorise les valeurs null en tant que clé et valeur alors que Hashtable n'autorise pas les valeurs nulles).
2. HashMap ne garantit pas que l'ordre de la carte restera constant dans le temps.
3. HashMap est non synchronisé alors que Hashtable est synchronisé.
4. Iterator dans le HashMap est à sécurité intégrée alors que l'énumérateur de la Hashtable ne l'est pas et lance ConcurrentModificationException si un autre thread modifie structurellement la carte en ajoutant ou en supprimant tout élément sauf la propre méthode remove() de l'itérateur. Mais ce n'est pas un comportement garanti et sera fait par JVM au meilleur effort.

Note sur quelques termes importants

1. 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é.
2. Fail-safe est pertinent 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 l'objet de collection "structurellement", une exception de modification simultanée sera levée. C'est possible pour d'autres threads cependant pour invoquer la méthode " set "car elle ne modifie pas la collection"structurellement". Cependant, si avant d'appeler "set", la collection a été modifiée structurellement," IllegalArgumentException " sera levée.
3. Structurellement modification signifie la suppression ou l'insertion d'un élément qui pourrait effectivement changer la structure de map.

HashMap peut être synchronisé par

Map m = Collections.synchronizeMap(hashMap);

Map fournit des vues de collection au lieu de la prise en charge directe de l'itération par l'Énumération objet. Les vues de collection améliorent considérablement le expressivité de l'interface, comme discuté plus loin dans cette section. Map vous permet d'itérer sur des clés, des valeurs ou des paires clé-valeur; Hashtable ne fournit pas la troisième option. La carte fournit un moyen sûr pour supprimer des entrées au milieu de l'itération; Hashtable ne l'a pas fait. Enfin, Map corrige une déficience mineure dans l'interface Hashtable. Hashtable a une méthode appelée contains, qui renvoie true si le Hashtable contient une valeur donnée. Compte tenu de son nom, vous vous attendez à ce méthode pour retourner true si la table de hachage contenait une clé donnée, car la clé est le mécanisme d'accès principal pour une table de hachage. cartographie interface élimine cette source de confusion en renommant la méthode containsValue. En outre, cela améliore la cohérence de l'interface - containsValue parallels containsKey.

L'Interface De La Carte

HashMap: Une implémentation de l'interface Map qui utilise des codes de hachage pour indexer un tableau. Hashtable: Salut, 1998 appelé. Ils veulent récupérer leur API collections.

Sérieusement cependant, vous feriez mieux de rester loin de Hashtable tout à fait. Pour les applications à thread unique, vous n'avez pas besoin de la surcharge supplémentaire de la synchronisation. Pour les applications hautement simultanées, la synchronisation paranoïaque peut entraîner une famine, des blocages ou des pauses inutiles dans la collecte des ordures. Comme Tim Howland l'a souligné, vous pourriez utilisez plutôt ConcurrentHashMap.

Gardez à l'esprit 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 l'interface Map. Ainsi était Vector et Stack.

Par conséquent, restez toujours loin d'eux dans le nouveau code car il y a toujours une meilleure alternative dans le JCF comme d'autres l'avaient souligné.

Voici le Java collection feuille de triche, que vous trouverez utile. Notez que le bloc gris contient la classe héritée HashTable, Vector et Pile.

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

Notez également que Hashtable étend la classe Dictionary, qui en tant qu'état Javadocs , est obsolète et a été remplacée par l'interface Map.

Jetez un oeil à ce graphique. Il fournit des comparaisons entre différentes structures de données avec HashMap et Hashtable. La comparaison est précise, claire et facile à comprendre.

Java Collection De La Matrice

Hashtable est similaire à la HashMap et possède une interface similaire. Il est recommandé d'utiliser HashMap, sauf si vous avez besoin d'une prise en charge pour les applications héritées ou si vous avez besoin d'une synchronisation, car les méthodes Hashtables sont synchronisées. Donc, dans votre cas, comme vous n'êtes pas multi-threading, HashMaps sont votre meilleur pari.

Il y a beaucoup de bonnes réponses déjà postées. J'ajoute quelques nouveaux points et je le résume.

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

HashMap

1. HashMap n'est pas synchronisé. Il n'est pas sûr pour les threads et ne peut pas être partagé entre de nombreux threads sans code de synchronisation.
2. HashMap autorise une clé null et plusieurs valeurs null.
3. HashMap est une nouvelle classe introduite dans JDK 1.2.
4. HashMap est rapide.
5. Nous pouvons faire le HashMap comme synchronisé en appelant ce code
   Map m = Collections.synchronizedMap(HashMap);
6. HashMap est parcouru par l'itérateur.
7. L'itérateur dans HashMap est rapide.
8. HashMap hérite de la classe AbstractMap.

Je ne sais pas si c'est le cas.]}

1. Hashtable est synchronisé. Il est thread-safe et peut être partagé avec de nombreux threads.
2. Hashtable n'autorise aucune clé ou valeur null.
3. Hashtable est une classe héritée.
4. Hashtable est lent.
5. Hashtable est synchronisé en interne et ne peut pas être désynchronisé.
6. Hashtable est parcouru par l'énumérateur et l'itérateur.
7. L'énumérateur dans Hashtable n'est pas rapide.
8. Hashtable hérite de la classe Dictionary.

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 Hashtable ne l'est pas et lance ConcurrentModificationException si un autre Thread modifie structurellement la carte en ajoutant ou en supprimant tout élément sauf la propre méthode remove() de l'itérateur. Mais ce n'est pas un comportement garanti et sera fait par JVM au meilleur effort."

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

En plus de tous les autres aspects importants déjà mentionnés ici, l'API Collections (par exemple l'interface Map) est constamment modifiée pour se conformer aux ajouts "les plus récents et les plus importants" aux spécifications Java.

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

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();
}

En Java 1.8, nous sommes également promis 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 ne le feront pas la terre en 1.8... :(

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

• Table de hachage est synchronisé, si vous l'utilisez dans un seul fil, vous pouvez utiliser HashMap, qui est une version non synchronisées. Les objets non synchronisés sont souvent un peu plus performants. Soit dit en passant, 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. Youn peut envelopper une carte non synchronisée dans une carte synchronisée en utilisant:

  Map m = Collections.synchronizedMap(new HashMap(...));
  

• Table de hachage ne peut contient un objet non nul comme clé ou comme valeur. HashMap peut contenir une clé null et des valeurs null.

• Les itérateurs renvoyés par Map sont rapides à l'échec, 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 à une modification simultanée, l'itérateur échoue rapidement et proprement, plutôt que de risquer un comportement arbitraire et non déterministe à un moment indéterminé le temps dans l'avenir. Alors que les énumérations renvoyées par les méthodes keys et elements de Hashtable ne sont pas rapides.

• HashTable et HashMap sont membres du Java Collections Framework (depuis Java 2 platform v1.2, HashTable a été modifié pour implémenter l'interface Map).

• HashTable est considéré comme du code hérité, la documentation conseille d'utiliser ConcurrentHashMap {[6] } à la place de Hashtable si un thread-safe hautement concurrent la mise en œuvre est souhaitée.

• HashMap ne garantit pas l'ordre dans lequel les éléments sont retournés. Pour HashTable, je suppose que c'est la même chose mais je ne suis pas tout à fait sûr, je ne trouve pas de ressource qui l'indique clairement.

HashMap et Hashtable ont également des différences algorithmiques significatives. Personne ne l'a mentionné auparavant, c'est pourquoi je l'aborde. 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 seau et remuera très bien les éléments pour les types d'éléments généraux. Cependant, l'implémentation Hashtable fournit 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 se traduira par de meilleures performances que HashMap, c'est-à-dire moins de collisions dans certains cas.

Séparé des différences évidentes discutées en détail dans cette question, je vois le Hashtable comme une voiture "à entraînement manuel" où vous avez un meilleur contrôle sur le hachage et le HashMap comme la contrepartie "à entraînement automatique" qui fonctionnera généralement bien.

Hashtable est synchronisé, alors que HashMap ne l'est pas. Cela rend Hashtable plus lent que Hashmap.

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

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

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

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

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

" Membre du Cadre de superclasse, Héritage et Collection

Hashtable est une classe héritée introduite dans JDK1.0, qui est une sous-classe de la classe Dictionary. De JDK1.2 Hashtable est repensé pour implémenter l'interface Map pour faire un membre du framework 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 le 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 de la capacité 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). Où comme 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. De 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éliorer les performances dans le pire des cas de O(n) à O(log n). Lors de la conversion de la liste en arbre binaire, hashcode est utilisé comme variable de ramification. S'il y a deux hashcodes différents dans le même compartiment, l'un est considéré comme plus grand et va à droite de l'arbre 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 faire les clés de HashMap comparable. Lors de l'ajout d'entrées si la taille du compartiment atteint TREEIFY_THRESHOLD = 8, convertissez la liste chaînée d'entrées en un arbre équilibré, lors de la suppression d'entrées inférieures à TREEIFY_THRESHOLD et au plus UNTREEIFY_THRESHOLD = 6 reconvertira l'arbre équilibré en liste chaînée d'entrées. ^{Java 8 SRC, pile}

" Collection-vue itération, Fail-Fast et Fail-Safe

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

Iterator c'est un échec rapide dans la nature. j'.e il jette ConcurrentModificationException si une collection est modifiée lors d'une itération autre que sa propre méthode remove (). Où comme Enumeration est de nature fail-safe. Il ne lève aucune exception si une collection est modifiée lors de l'itération.

Selon les documents de l'API Java, l'itérateur est toujours préféré à l'énumération.

_{REMARQUE: La fonctionnalité de l'interface d'Énumération est reproduit par l'interface Iterator. De plus, l'itérateur ajoute un opération de suppression facultative, et a des noms de méthode plus courts. Les nouvelles implémentations devraient envisager d'utiliser Iterator de préférence à l'énumération.}

Dans Java 5 introduit l'interface ConcurrentMap: ConcurrentHashMap - une implémentation hautement concurrente et performante ConcurrentMap 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 Hashtable: in outre l'implémentation de ConcurrentMap, il prend en charge toutes les méthodes "héritées" propres à Hashtable.

• Chaque valeur de HashMapEntrys est volatile assurant ainsi la cohérence du 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 / énumération; cela permet des lectures simultanées et modifications 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 à null d'être utilisé 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();
    }
}

" Null Clés Et Les Valeurs Null

HashMap permet au maximum une clé null et n'importe quel nombre de valeurs null. Où comme Hashtable n'autorise même pas une seule clé null et une seule valeur null, si la clé ou la valeur null est alors elle lève NullPointerException. ^Exemple

" Synchronisé Thread Safe)

Hashtable est synchronisé en interne. Par conséquent, il est très sûr d'utiliser Hashtable dans des applications multithread. Où que HashMap n'est pas synchronisé en interne. Par conséquent, il n'est pas sûr d'utiliser HashMap dans des applications multithread sans synchronisation externe. Vous peut synchroniser en externe HashMap en utilisant la méthode Collections.synchronizedMap().

" les Performances

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

@Voir

• Un arbre rouge-noir est une sorte d'arbre de recherche binaire auto-équilibrant
• Amélioration des performances pour HashMap dans Java 8

En dehors des différences déjà mentionné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 si des collisions de hachage élevées existent, le pire des cas lors de la recherche est

O(log(n)) pour HashMap Vs O(n) Hashtable.

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

POUR INFO, actuellement,

• TREEIFY_THRESHOLD = 8: si un compartiment contient plus de 8 nœuds, la liste chaînée est transformée en un 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.

1.Hashmap et HashTable stockent la clé et la valeur.

2.Hashmap peut stocker une clé comme null. Hashtable impossible de 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);

Il y a 5 différentiations de base avec HashTable et HashMaps.

1. Maps vous permet d'itérer et de récupérer des clés, des valeurs et les deux paires clé-valeur, où HashTable n'a pas toute cette capacité.
2. Dans Hashtable, il y a une fonction contains (), qui est très déroutante à utiliser. Parce que le sens de contient est légèrement déviant. Que cela signifie contient la clé ou contient la valeur? difficile à comprendre. Même chose dans les cartes que nous avons ContainsKey () et ContainsValue() fonctions, qui sont très faciles à comprendre.
3. Dans hashmap, vous pouvez supprimer un élément lors de l'itération, en toute sécurité. où comme ce n'est pas possible dans les tables de hachage.
4. Les tables de hachage sont par défaut synchronisées, elles peuvent donc être utilisées facilement avec plusieurs threads. Où comme HashMaps ne sont pas synchronisés par défaut, il peut donc être utilisé avec un seul thread. Mais vous pouvez toujours convertir HashMap en synchronized en utilisant la classe synchronizedMap de Collections util (Map m) fonction.
5. HashTable n'autorise pas les clés null ou les valeurs null. Où comme HashMap permet une clé null et plusieurs valeurs null.

Ma petite contribution :

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

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

3. La troisième différence sur Hashtable vs HashMap est que Hashtable est une classe obsolète et vous devriez utiliser ConcurrentHashMap à la place de Hashtable en Java.

HashTable est une classe héritée dans le jdk qui ne devrait plus être utilisée. Remplacez les utilisations par ConcurrentHashMap. Si vous n'avez pas besoin de sécurité des threads, utilisez HashMap qui n'est pas threadsafe mais plus rapide et utilise moins de mémoire.

1)Hashtable est synchronisé alors que hashmap ne l'est pas. 2) Une autre différence est que l'itérateur dans le HashMap est à sécurité intégrée alors que l'énumérateur de la table de hachage ne l'est pas.Si vous modifiez la carte pendant l'itération, vous le saurez.

3)HashMap autorise les valeurs null, alors que Hashtable ne le fait pas.

HashMap:- C'est une classe disponible dans java.util package et il est utilisé pour stocker l'élément au format clé et valeur.

Hashtable: - C'est 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 pour les clés et les valeurs. Vous obtiendrez un NullPointerException si vous ajoutez une valeur nulle. Il est synchronisé. Donc, il est livré avec son coût. Un seul thread peut accéder àHashTable à 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));

    }
}

HashMap:

HashMap est comme Hashtable mais il accepte également la paire clé valeur. Il permet null pour les clés et les valeurs. Sa performance est meilleure que HashTable, car elle 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));

    }
}

HashMap et table de hachage

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

1) Hashtable et Hashmap implémentent le java.util.Carte d'interface 2) Hashmap et Hashtable sont la collection basée sur le hachage. et travailler sur le hachage. ce sont donc des similarités de 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 plus performant car il n'est pas sûr pour les threads. bien que les performances de Hashtable ne soient pas meilleures car elles sont sans danger pour les threads. donc, plusieurs threads ne peuvent pas accéder à Hashtable en même temps.

HashMaps vous donne 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 ne l'est pas.

La Synchronisation ou Thread-Safe :

La carte de hachage n'est pas synchronisée, elle n'est donc pas sécurisée et ne peut pas être partagée entre plusieurs threads sans bloc synchronisé approprié, alors que Hashtable est synchronisé et est donc sécurisé pour les threads.

Clés null et valeurs null:

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

Itération des valeurs:

Itérateur dans le HashMap est un itérateur 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 tout élément sauf la propre méthode remove() de l'itérateur.

Super-classe et Héritage :

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

Les Performances :

Comme HashMap n'est pas synchronisé, il est plus rapide que Table de hachage.

Se référer à http://modernpathshala.com/Article/1020/difference-between-hashmap-and-hashtable-in-java {[32] } pour des exemples et des questions d'entrevue et quiz liés à la collection Java