java example - Différences entre HashMap et Hashtable?




util put (25)

Outre tous les autres aspects importants déjà mentionnés ici, Collections API (par exemple, l'interface de carte) est en cours de modification constante pour se conformer aux "derniers et meilleurs" ajouts à la spécification Java.

Par exemple, comparez Java 5 Map itérant:

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, on nous promet également de pouvoir construire et accéder à HashMaps comme dans de bons vieux langages de script:

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

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

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

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

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


Il existe 5 différenciations 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. Where HashTable ne possède pas toutes ces fonctionnalités.
  2. Dans Hashtable, il y a une fonction contient (), ce qui est très déroutant à utiliser. Parce que la signification de contient est légèrement différente. Si cela signifie contient la clé ou contient de la valeur? difficile à comprendre. Même chose dans Maps, nous avons les fonctions ContainsKey () et ContainsValue (), qui sont très faciles à comprendre.
  3. Dans hashmap, vous pouvez supprimer un élément en itérant, en toute sécurité. où comme ce n'est pas possible dans les hashtables.
  4. Les tables de hachage sont synchronisées par défaut, ce qui permet de les utiliser facilement avec plusieurs threads. Là où 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 synchronisation à l'aide de la fonction synchronizedMap (Map m) de la classe Collections util.
  5. HashTable n'autorisera pas les clés NULL ou les valeurs NULL. Où en tant que HashMap autorise une clé NULL et plusieurs valeurs NULL.

HashMapest émulé et donc utilisable dans GWT client codealors Hashtablen'est pas.


  • HashTable est synchronisé. Si vous l’utilisez dans un seul thread, vous pouvez utiliser docs.oracle.com/javase/7/docs/api/java/util/HashMap.html , qui est une version non synchronisée. Les objets non synchronisés sont souvent un peu plus performants. En passant, si plusieurs threads accèdent simultanément à un HashMap et si au moins un des threads modifie structurellement la carte, celle-ci 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(...));
    
  • HashTable ne peut contenir qu'un objet non NULL en tant que clé ou valeur. HashMap peut contenir une clé NULL et des valeurs NULL.

  • Les itérateurs renvoyés par Map ont la capacité de résister rapidement, 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 par le biais de sa méthode de suppression, l'émetteur lève une exception ConcurrentModificationException . Ainsi, face aux modifications simultanées, l'itérateur échoue rapidement et proprement, au lieu de risquer un comportement non déterministe arbitraire à une date future indéterminée. Alors que les énumérations retournées par les méthodes de clés et d'éléments de Hashtable ne sont pas rapides.

  • HashTable et HashMap sont membres de Java Collections Framework (depuis la plate-forme Java 2 version 1.2, HashTable a été mis à niveau pour implémenter l'interface Map).

  • HashTable étant considéré comme du code hérité, la documentation conseille d'utiliser ConcurrentHashMap à la place de Hashtable si une implémentation hautement concurrente sécurisée pour les threads 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: - C'est une classe disponible dans le package java.util et elle est utilisée pour stocker l'élément au format clé et valeur.

Hashtable: -Il s'agit d'une classe héritée reconnue dans le cadre de la collection


En plus de ce que HashMap dit, HashMap autorise les valeurs NULL, contrairement à Hashtable .

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


Notez que beaucoup de réponses indiquent que Hashtable est synchronisé. En pratique, cela vous rapporte très peu. La synchronisation est sur les méthodes accesseur / mutateur arrêtera l'ajout ou la suppression simultanés de deux threads 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 de mettre" - c'est-à-dire de rechercher une entrée dans la carte et de 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.

Un HashMap synchronisé de manière équivalente peut être obtenu par:

Collections.synchronizedMap(myMap);

Mais pour implémenter correctement cette logique, vous avez besoin d’ une synchronisation supplémentaire du formulaire:

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

Même une itération sur les entrées d'une table de hachage (ou une table de hachage obtenue par Collections.synchronizedMap) n'est pas protégée contre les threads, sauf si vous protégez également la mappe contre la modification par une synchronisation supplémentaire.

Les implémentations de l'interface ConcurrentMap (par exemple, ConcurrentHashMap ) résolvent certaines de ces difficultés en incluant une sémantique check-then-act sécurisée pour les threads, telle que:

ConcurrentMap.putIfAbsent(key, value);

1) Hashtable est synchronisé alors que hashmap ne l’est pas. 2) Une autre différence est que l'itérateur dans HashMap est sans faille alors que l'énumérateur de Hashtable ne l'est pas. Si vous modifiez la carte en effectuant une itération, vous saurez.

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


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

HashMap et Hashtable sont tous deux utilisés pour stocker des données sous forme de clé et de valeur . 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 présentées ci-dessous.

HashMap

  1. 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é.
  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 rendre la HashMap synchronisée en appelant ce code
    Map m = Collections.synchronizedMap(HashMap);
  6. HashMap est traversé par Iterator.
  7. Iterator dans HashMap est rapide à la faillite.
  8. HashMap hérite de la classe AbstractMap.

Table de hachage

  1. Hashtable est synchronisé. Il est thread-safe et peut être partagé avec de nombreux threads.
  2. Hashtable n'autorise aucune clé ou valeur nulle.
  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 Enumerator et Iterator.
  7. L'énumérateur dans Hashtable n'est pas rapide.
  8. Hashtable hérite de la classe Dictionary.

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


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 autrement identiques en termes de fonctionnalité.


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


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

Sérieusement, il vaut mieux rester loin de Hashtable . Pour les applications à un seul thread, vous n'avez pas besoin de la surcharge de la synchronisation. Pour les applications hautement concurrentes, la synchronisation paranoïaque peut entraîner la famine, des blocages ou des pauses inutiles dans la récupération de place. Comme Tim Howland l'a souligné, vous pouvez utiliser ConcurrentHashMap place.


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


Cette question est souvent posée en entrevue pour vérifier si le candidat comprend l’usage correct des classes de collecte et s’intéresse aux solutions de remplacement disponibles.

  1. 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 NULL en tant que clé et valeur alors que Hashtable n'autorise pas les valeurs NULL).
  2. HashMap ne garantit pas que l'ordre de la carte restera constant dans le temps.
  3. HashMap n'est pas synchronisé alors que Hashtable est synchronisé.
  4. Iterator dans HashMap est protégé contre toute défaillance tandis que l'énumérateur de Hashtable ne le fait pas et lève une exception ConcurrentModificationException si un autre thread modifie la carte de manière structurelle en ajoutant ou en supprimant tout élément, à l'exception de la méthode remove () d'Iterator. Mais ce n'est pas un comportement garanti et JVM le fera de son mieux.

Note sur quelques termes importants

  1. Synchronisé signifie qu'un seul thread peut modifier une table de hachage à un moment donné. En gros, 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. Il est toutefois possible que d'autres threads invoquent la méthode "set" car ils ne modifient pas la collection "structurellement". Cependant, si avant d'appeler "set", la collection a été modifiée structurellement, "IllegalArgumentException" sera levé.
  3. Par modification structurelle, on entend supprimer ou insérer un élément susceptible de modifier efficacement la structure de la carte.

HashMap peut être synchronisé par

Map m = Collections.synchronizeMap(hashMap);

Map fournit des vues Collection au lieu d'un support direct pour l'itération via les objets Enumeration. Les vues de collection améliorent considérablement l'expressivité de l'interface, comme indiqué plus loin dans cette section. La carte vous permet de parcourir 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 de supprimer des entrées au milieu d'une itération; Hashtable n'a pas. Enfin, Map corrige une lacune mineure dans l'interface Hashtable. Hashtable a une méthode appelée contient, qui renvoie true si Hashtable contient une valeur donnée. Étant donné son nom, vous vous attendriez à ce que cette méthode retourne la valeur true si la table de hachage contient une clé donnée, car la clé est le mécanisme d'accès principal d'une table de hachage. L'interface de carte élimine cette source de confusion en renommant la méthode includesValue. En outre, cela améliore la cohérence de l'interface - contientValue parallels contientKey.

L'interface de la carte


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

  1. Hashtable est synchronized , alors que HashMap ne l’est pas. Cela améliore HashMap pour les applications non-threadées, car les objets non synchronisés fonctionnent généralement mieux que les objets synchronisés.

  2. Hashtable n'autorise pas null clés ou les valeurs null . HashMap autorise une clé null et un nombre quelconque de valeurs null .

  3. LinkedHashMap est l'une des sous-classes de LinkedHashMap . Par conséquent, si vous souhaitez obtenir un ordre d'itération prévisible (qui est l'ordre d'insertion par défaut), vous pouvez facilement remplacer l'objet HashMap par un objet LinkedHashMap . Ce ne serait pas aussi facile si vous utilisiez Hashtable .

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


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

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

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

FYI, actuellement,

  • TREEIFY_THRESHOLD = 8 : si un TREEIFY_THRESHOLD = 8 contient plus de 8 noeuds, la liste liée est transformée en une arborescence équilibrée.
  • UNTREEIFY_THRESHOLD = 6 : lorsqu'un seau devient trop petit (en raison de la suppression ou du redimensionnement), l'arbre est reconverti en liste liée.

Ma petite contribution:

  1. La première et la plus importante différence entre Hashtableet HashMapest que, HashMapn’est pas thread-safe alors qu’il Hashtables’agit d’une collection thread-safe.

  2. La deuxième différence importante entre Hashtableet HashMapest la performance, puisque HashMapnon synchronisée, elle fonctionne mieux que Hashtable.

  3. La troisième différence sur Hashtablevs HashMapest que Hashtablec'est une classe obsolète et que vous devriez utiliser ConcurrentHashMapà la place de HashtableJava.


HashMap et HashTable

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

1) Hashtable et Hashmap implémentent l'interface java.util.Map. 2) Hashmap et Hashtable constituent la collection basée sur le hachage. et travaillant sur le hachage. Donc, ce sont la similitude 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 offre de meilleures performances car il n'est pas thread-safe Bien que les performances de Hashtable ne soient pas meilleures, elles sont thread-safe. donc plusieurs threads ne peuvent pas accéder à Hashtable en même temps.


Une autre différence essentielle entre hashtable et hashmap réside dans le fait qu'Iterator dans HashMap est ultra-rapide alors que l'énumérateur de Hashtable ne le fait pas et renvoie ConcurrentModificationException si un autre thread modifie la carte de manière structurelle en ajoutant ou en supprimant tout élément, à l'exception de la méthode de suppression () d'Iterator. Mais ce n'est pas un comportement garanti et JVM le fera de son mieux. "

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


Basé sur l'info here , je vous recommande d'aller avec HashMap. Je pense que le plus gros avantage est que Java vous empêchera de le modifier pendant que vous le parcourez, à moins que vous ne le fassiez par le biais de l'itérateur.


N'oubliez pas que HashTable était une classe héritée avant l'introduction de Java Collections Framework (JCF), qui a été ultérieurement adaptée pour implémenter l'interface Map . De même que Vector et Stack .

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

Voici la feuille de triche pour la collection Java que vous trouverez utile. Notez que le bloc gris contient les classes héritées HashTable, Vector et Stack.


Une Collection - parfois appelée conteneur - est simplement un objet qui regroupe plusieurs éléments dans une seule et même unité. Collection sont utilisées pour stocker, récupérer, manipuler et communiquer des données agrégées. Un framework de collections W est une architecture unifiée pour représenter et manipuler des collections.

HashMap JDK1.2 et Hashtable JDK1.0 sont utilisés pour représenter un groupe d'objets représentés dans la paire <Key, Value> . Chaque paire <Key, Value> est appelée objet Entry . La collection d'entrées est référé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 d'une clé particulière. les valeurs d'une collection peuvent être dupliquées.]

« Membre Superclass, Legacy and 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 JDK1.2 pour implémenter l’ interface Map afin de devenir un membre de la structure de collecte. HashMap est membre de Java Collection Framework depuis 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é correspond au nombre de compartiments dans la table de hachage et la capacité initiale est simplement la capacité au moment de la création de la table de hachage. Notez que la table de hachage est ouverte: dans le cas d'une " collision hash ", un seul compartiment stocke plusieurs entrées, qui doivent faire l'objet d'une recherche séquentielle. Le facteur de charge est une mesure de la capacité de la table de hachage à être pleine 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). Where as as Hashtable construit une table de hachage vide avec une capacité initiale par défaut (11) et un facteur de charge / taux 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 la carte dans des listes liées. À partir de Java8 pour HashMap si le HashMap hachage dépasse un certain seuil, ce dernier passera d'une 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 arborescence binaire, hashcode est utilisé comme variable de branchement. S'il existe deux codes de hachage différents dans le même compartiment, l'un est considéré comme plus gros et se place à la droite de l'arbre et l'autre à la gauche. Mais lorsque les deux codes de hachage sont égaux, HashMap suppose que les clés sont comparables et compare la clé pour déterminer la direction afin qu'un ordre puisse être maintenu. Il est HashMap comparable les clés de HashMap . Lors de l'ajout d'entrées si la taille du TREEIFY_THRESHOLD = 8 atteint TREEIFY_THRESHOLD = 8 convertissez la liste chaînée d'entrées en un arbre équilibré. TREEIFY_THRESHOLD de la suppression d'entrées inférieures à TREEIFY_THRESHOLD et au plus, UNTREEIFY_THRESHOLD = 6 reconvertira l'arborescence équilibrée en liste chaînée. Java 8 SRC , stackpost

«Itération Collection-view, Fail-Fast et Fail-Safe

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

Iterator est un échec rapide dans la nature. c'est-à-dire qu'il lève une exception ConcurrentModificationException si une collection est modifiée en itérant autre que sa propre méthode remove (). En tant que Enumeration nature est sans faille. Il ne lève aucune exception si une collection est modifiée en itérant.

Selon les documents de l'API Java, Iterator est toujours préférable à l'énumération.

REMARQUE: la fonctionnalité de l'interface Enumeration est dupliquée par l'interface Iterator. En outre, Iterator ajoute une opération facultative de suppression et a des noms de méthode plus courts. Les nouvelles implémentations devraient envisager d'utiliser Iterator de préférence à Énumération.

En Java 5, ConcurrentMap Interface : ConcurrentHashMap une implémentation ConcurrentMap hautement performante et hautement concurrente, ConcurrentMap par une table de hachage. Cette implémentation ne bloque jamais lors des extractions et permet au client de sélectionner le niveau de simultanéité pour les mises à jour. Il est conçu pour remplacer Hashtable : en plus de la mise en œuvre de ConcurrentMap , il prend en charge toutes les méthodes "classiques" propres à Hashtable .

  • HashMapEntry valeur de chaque objet HashMapEntry est volatile , ce qui garantit la cohérence du grain fin pour les modifications HashMapEntry et les lectures ultérieures. chaque lecture reflète la dernière mise à jour terminée

  • Les itérateurs et les énumérations sont sans échec - ils reflètent l'état à un moment donné depuis la création de l'itérateur / énumération; Cela permet des lectures et des modifications simultanées au détriment de la cohérence. 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 n'autorise pas l'utilisation de null en tant que 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 Keys And Null Values

HashMap autorise au maximum une clé NULL et un nombre quelconque de valeurs NULL. Where as Hashtable n'autorisant même pas une seule clé NULL et une valeur NULL, si la clé ou la valeur NULL est, elle renvoie alors NullPointerException. Example

« Synchronisé, thread sécurisé

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

« Performance

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

@Voir


Hashtable est considéré comme du code hérité. Il n'y a rien dans Hashtable qui ne puisse pas être utilisé avec HashMap ou des dérivations de HashMap , aussi, pour le nouveau code, je ne vois aucune justification pour revenir à Hashtable .


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


La classe imbriquée est un terme très général: chaque classe qui n'est pas de niveau supérieur est une classe imbriquée. Une classe interne est une classe imbriquée non statique. Joseph Darcy a écrit une très belle explication sur les classes imbriquées, internes, membres et de premier niveau .





java collections hashmap hashtable