Différences entre HashMap et Hashtable?

notez que beaucoup de réponses indiquent que le Hashtable est synchronisé. Dans la pratique, cela vous achète très peu. la synchronisation est sur les méthodes accessor / mutator va arrêter l'ajout ou la suppression de deux threads de la carte simultanément, mais dans le monde réel, vous aurez souvent besoin de synchronisation supplémentaire.

un idiome très courant est de" vérifier puis mettre " - c'est-à-dire chercher 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.

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

Collections.synchronizedMap(myMap);

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

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

même itération sur les entrées D'un Hashtable (ou un HashMap obtenu par Collections.synchronizedMap) n'est pas sécurisé sauf si vous aussi empêcher la modification de la carte par une synchronisation supplémentaire.

implémentations de l'interface Compimentmap (par exemple Compimenthashmap ) résoudre certains de ces en incluant thread safe check-then-act sémantique tel que:

ConcurrentMap.putIfAbsent(key, value);

Hashtable est considéré comme un code de legs. Il n'y a rien au sujet de Hashtable qui 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 en entrevue pour vérifier si le candidat comprend l'utilisation correcte des classes de collecte et est au courant des solutions de rechange disponibles.

1. la classe HashMap est à peu près équivalente à Hashtable, sauf qu'elle n'est pas synchronisée et permet nulls. (HashMap permet les valeurs nulles comme clé et valeur alors que Hashtable ne permet pas les nulls).
2. HashMap ne garantit pas que l'ordre de la carte restent constants au cours du temps.
3. HashMap est non synchronisé alors que Hashtable est synchronisé.
4. Itérateur dans la table de hachage est fail-safe tandis que l'agent recenseur pour la table de hachage n'est pas et de le jeter ConcurrentModificationException si un autre Thread modifie la carte structurellement par l'ajout ou la suppression de tout élément à l'exception Itérateur propre méthode remove (). Mais ce n'est pas un comportement garanti et sera fait par JVM sur le meilleur effort.

Note sur certains termes importants

1. synchrone signifie qu'un seul thread peut modifier une table de hachage à un moment donné. Fondamentalement, cela signifie que n'importe quel thread avant d'effectuer une mise à jour sur un hashtable devra acquérir un verrou sur l'objet pendant 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 collection et qu'un autre thread essaie pour modifier l'objet collection "structurellement", une exception de modification concurrente sera lancée. Il est possible pour d'autres threads cependant d'invoquer la méthode "set" puisqu'elle ne modifie pas la collection "structurellement". Cependant, si avant d'appeler "set", la collection a été modifiée structurellement, "IllegalArgumentException" sera lancé.
3. modification structurale: suppression ou insertion d'un élément susceptible de modifier effectivement la structure de la carte.

HashMap peut être synchronisé par

Map m = Collections.synchronizeMap(hashMap);

Map fournit des vues de collecte au lieu d'un support direct pour l'itération par l'Énumération des objets. Les vues de la Collection l'expressivité de l'interface, comme indiqué plus loin dans cette section. Map vous permet d'itérer des clés, des valeurs ou des paires de clés; Hashtable ne fournit pas la troisième option. La carte offre un moyen sûr pour supprimer des entrées au milieu de itération; table de hachage n'a pas. Enfin, Map corrige une lacune mineure dans l'interface Hashtable. Hashtable a une méthode appelée contains, qui renvoie true si le Table de hachage contient une valeur donnée. Donné son nom, vous vous attendez à ce méthode pour retourner true si le Hashtable contenait une clé donnée, parce que la clé est le mécanisme d'accès principal d'une table hachurée. cartographie interface élimine cette source de confusion en renommant la méthode containsValue. En outre, cela améliore l'interface cohérence - 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 l'API de leurs collections.

sérieusement, tu ferais mieux de rester loin de Hashtable . Pour les applications monofilées, vous n'avez pas besoin de la surcharge de synchronisation. Pour les applications hautement concurrentes, la synchronisation paranoïaque peut conduire à la famine, à des blocages ou à des déchets inutiles la collecte des pauses. Comme Tim Howland l'a souligné, vous pouvez utiliser ConcurrentHashMap à la place.

gardez à l'esprit que HashTable était la classe legacy avant que Java Collections Framework (JCF) a été introduit et a ensuite été modifié pour mettre en œuvre l'interface Map . Tout comme Vector et Stack .

par conséquent, toujours rester loin d'eux dans le nouveau code car il y a toujours meilleure alternative dans le JCF comme d'autres l'ont souligné.

Voici la Java collection cheat sheet que vous trouverez utile. Notez que le bloc gris contient le HashTable de classe legacy, Le Vecteur et la pile.

en plus de ce que izb a dit, HashMap permet des valeurs nulles, tandis que le Hashtable ne le fait pas.

notez Également que Hashtable s'étend la Dictionary classe", comme le Javadoc de l'état, est obsolète et a été remplacé par le Map de l'interface.

regardez ce tableau. 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 Matrix

Hashtable est similaire au HashMap et a une interface similaire. Il est recommandé d'utiliser HashMap , sauf si vous avez besoin de support pour les applications traditionnelles ou si vous avez besoin de 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 ya beaucoup de bonne réponse déjà posté. J'ajoute quelques nouveaux points et je les résume.

HashMap et Hashtable sont utilisés pour stocker données sous forme de clé et de valeur . Tous deux utilisent la technique du hachage pour stocker des Clés uniques. Mais il y a beaucoup de différences entre les classes HashMap et Hashtable qui sont données ci-dessous.

table de hachage

1. HashMap n'est pas synchronisé. Il n'est pas sûr et ne peut pas être partagé entre de nombreux threads sans un code de synchronisation approprié.
2. HashMap permet une clé nulle et plusieurs valeurs nulles.
3. HashMap est une nouvelle classe introduite dans la 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 traversé par itérateur.
7. Itérateur HashMap est fail-fast.
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 ne permet pas toute clé ou valeur nulle.
3. Hashtable est un héritage de la classe.
4. Hashtable est lent.
5. Hashtable est synchronisé en interne et ne peut pas être non synchronisé.
6. Hashtable est traversé par l'agent Recenseur et de l'Itérateur.
7. Énumérateur Hashtable n'est pas fail-fast.
8. Hashtable hérite de la classe du dictionnaire.

Autres lectures Quelle est la différence entre HashMap et table de hachage en Java?

une autre différence clé entre hashtable et hashmap est que L'itérateur dans le HashMap est rapide à l'échec tandis que l'énumérateur pour le Hashtable n'est pas et jette ConcurrentModificationException si un autre Thread modifie la carte structurellement 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 sur le 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 modifiée tout le temps pour se conformer aux "derniers et plus grands" ajouts à la spécification Java.

par exemple, comparer la carte Java 5 itérant:

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

par rapport à la vieille table de hachage approche:

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

en Java 1.8 on nous promet aussi de pouvoir construire et accéder à des HashMaps comme dans bon vieux les langages de script:

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

mise à Jour: Non, ils ne sont pas des terres en 1.8... : (

est-ce que les améliorations de la collection du projet Coin seront en JDK8?

• HashTable est synchronisé, si vous l'utilisez dans un seul thread , vous pouvez utiliser HashMap , qui est une version non synchronisée. Les objets non synchronisés sont souvent un peu plus performants. D'ailleurs, si plusieurs threads accèdent simultanément à un HashMap, et qu'au moins un des threads modifie la structure de la carte, il doit être synchronisé extérieurement. 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 contenir que des non-null objet comme une clé ou une valeur. HashMap peut contenir une clé nulle et des valeurs nulles.

• les itérateurs retournés par Map sont fail-fast, si la map est modifiée structurellement à tout moment après la création de l'itérateur, de quelque manière que ce soit, sauf par la méthode de suppression de l'itérateur, l'itérateur lancera un ConcurrentModificationException . Ainsi, face à des concurrentes la modification, l'itérateur échoue rapidement et proprement, plutôt que de risquer un comportement arbitraire, non-déterministe à un moment indéterminé dans le futur. alors que les énumérations retournées par les méthodes de touches et d'éléments de Hashtable ne sont pas fail-fast.

• HashTable et HashMap sont membres du Java Collections Framework (depuis la plate-forme Java 2 v1.2, HashTable a été modernisé pour mettre en œuvre la carte interface.)

• HashTable est considéré comme un code d'héritage, la documentation conseille d'utiliser Concordenthashmap à la place du Hashtable si un thread-safe Très-mise en œuvre concurrente 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 d'importantes algorithmique des différences aussi bien. Personne ne l'a mentionné auparavant, c'est pourquoi je le soulève. HashMap va construire une table de hachage avec une puissance de deux tailles, l'augmenter dynamiquement de sorte que vous avez au plus environ huit éléments (collisions) dans n'importe quel seau et Remuera les éléments très bien pour les types d'éléments généraux. Cependant, l'implémentation Hashtable offre un meilleur contrôle sur le hachage si vous savez ce que vous faites, c'est-à-dire que vous pouvez fixer la taille de la table en utilisant par exemple le nombre premier Le plus proche de la taille de votre domaine de valeurs et cela se traduira par de meilleures performances que HashMap, c'est-à-dire moins de collisions dans certains cas.

mis à part les 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 fonctionne 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 l'info ici , je recommande d'aller avec HashMap. Je pense que le plus grand avantage est que Java vous empêchera de le modifier pendant que vous itérez au-dessus de lui, à moins que vous ne le fassiez par le biais de l'itérateur.

pour les applications filetées, vous pouvez souvent vous en tirer avec Compimenthashmap - 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 sont utilisés pour stocker, extraire, manipuler et communiquer des données agrégées. A collections framework ^W est une architecture unifiée pour représenter et manipuler les collections.

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

" super-classe, l'Héritage et la structure de Collecte membre

Hashtable est une sous-classe introduite dans JDK1.0 , qui est une sous-classe de la classe du dictionnaire. De JDK1.2 Hashtable est modifié pour mettre en œuvre l'interface de carte pour en faire un membre de cadre 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é est le nombre de seaux 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 " hash collision ", un seul seau stocke des entrées multiples, qui doivent être recherchées de façon séquentielle. Le facteur de charge est une mesure de la capacité de la table de hachage avant que sa capacité soit automatiquement augmentée.

HashMap construit une table de hachage vide avec l'initiale par défaut capacité (16) et le facteur de charge par défaut (0,75). Où comme Hashtable construit le hashtable vide avec une capacité initiale par défaut (11) et un rapport de facteur de charge/remplissage (0.75).

" modification de la structure en cas de collision par hachage

HashMap , Hashtable en cas de collision de hachage, ils stockent les entrées de la carte dans des listes liées. De Java8 pour HashMap si compartiment de hachage qui croît au-delà d'un certain seuil, que le seau de passer de linked list of entries to a balanced tree . qui améliorent la performance du pire des scénarios de O(n) à O (log n). Lors de la conversion de la liste en arbre binaire, hashcode est utilisé comme une variable de branchement. S'il y a deux hashcodes différents dans le même seau, un est considéré comme plus grand et va vers la droite de l'arbre, et l'autre à gauche. Mais quand 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 pour prendre les clés de HashMap comparables . Sur l'ajout des entrées si la taille du seau atteint TREEIFY_THRESHOLD = 8 convertir la liste liée des entrées à un arbre équilibré, sur la suppression des entrées moins de TREEIFY_THRESHOLD et au plus UNTREEIFY_THRESHOLD = 6 reconvertiront l'arbre équilibré en une liste d'entrées liées. ^{Java 8 SRC , stackpost}

" Collection - voir itération, 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. j'.e il jette ConcurrentModificationException si une collection est modifié lors de l'itération autre que leur propre méthode remove (). Où as Enumeration est de nature à assurer la sécurité. Il ne jette pas d'exceptions si une collection est modifiée tout en itérant.

selon Java API Docs, Iterator est toujours préféré à l'énumération.

_{NOTE: la fonctionnalité de L'énumération l'interface est dupliquée par L'interface Itératrice. En outre, Iterator ajoute une opération de suppression optionnelle, et a des noms de méthode plus courts. Les nouvelles mises en oeuvre devraient envisager D'utiliser Iterator de préférence au dénombrement.}

dans Java 5 a introduit L'Interface de ConcurrentMap : ConcurrentHashMap - une implémentation hautement concurrente, haute performance ConcurrentMap soutenue par une table de hachage. Cette implémentation ne bloque jamais lors de l'exécution récupère et permet au client de sélectionner le niveau de simultanéité pour les mises à jour. Il est destiné à remplacer Hashtable par ConcurrentMap : en plus de la mise en œuvre de ConcurrentMap , il prend en charge toutes les méthodes "legacy" propres à Hashtable .

• Chaque HashMapEntry s valeur est volatile , ce qui permet d'assurer à grain fin de la cohérence pour a soutenu les modifications et les lectures subséquentes; chaque lecture reflète le plus mise à jour

• les itérateurs et les énumérations sont à L'abri des pannes - reflétant 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 prix d'une cohérence réduite. Ils ne jettent pas de Modificationexception Concurrentemodificationexception. Cependant, les itérateurs sont conçus pour être utilisés par un seul fil à 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.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();
    }
}

" Touches Nulles Et Valeurs Nulles

HashMap permet au maximum une touche null et n'importe quel nombre de valeurs null. Où comme Hashtable ne permet même pas une seule clé nulle et une valeur nulle, si la clé ou la valeur null, alors il jette NullPointerException. ^exemple

" Synchronisé, Sans Fil

Hashtable est synchronisé en interne. Par conséquent, il est très sûr d'utiliser Hashtable dans des applications multi-threads. Où HashMap n'est pas synchronisé en interne. Par conséquent, il n'est pas sûr à utiliser HashMap applications multi-threadées sans synchronisation externe. Vous pouvez synchroniser extérieurement HashMap en utilisant la méthode Collections.synchronizedMap() .

" Performance

comme Hashtable est synchronisé à l'intérieur, ce qui 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 en Java 8

outre les différences déjà mentionnées, il convient de noter que depuis Java 8, HashMap remplace dynamiquement les noeuds (liste liée) utilisés dans chaque seau avec TreeNodes (arbre rouge-noir), de sorte que même si de fortes collisions de hachage existent, le pire cas lors de la recherche est

O(log(n)) Pour HashMap Vs O (N) dans Hashtable .

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

FYI, actuellement,

• TREEIFY_THRESHOLD = 8 : si un seau contient plus de 8 noeuds, la liste liée est transformée en arbre équilibré.
• UNTREEIFY_THRESHOLD = 6 : quand un seau devient trop petit (en raison de l'enlèvement ou le redimensionnement) l'arbre est converti de nouveau à la liste liée.

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

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

il y a 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 de valeurs clés ainsi, où le HashTable n'a pas toute cette capacité.
2. dans Hashtable il y a une fonction contains(), qui est très confuse à utiliser. Parce que le sens de l'contient est légèrement divergentes. Qu'il s'agisse de Contient clé ou de valeur? difficile à comprendre. Même chose dans Cartes nous avons les fonctions ContainsKey() et ContainsValue (), qui sont très faciles à comprendre.
3. dans hashmap vous pouvez supprimer l'élément tout en itérant, en toute sécurité. où comme il n'est pas possible dans hashtables.
Les HashTables
4. sont par défaut synchronisés, de sorte qu'ils peuvent être utilisés facilement avec plusieurs threads. Lorsque les HashMaps ne sont pas synchronisés par défaut, ils peuvent être utilisés avec un seul thread. Mais vous pouvez encore convertir HashMap à synchronisé en utilisant des Collections fonction synchronizedMap(Map m) de la classe util.
Le HashTable
5. n'autorise pas les clés nulles ou les valeurs nulles. Où as HashMap permet une clé nulle, et plusieurs valeurs nulles.

ma petite contribution:

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

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

3. la troisième différence par rapport à Hashtable vs HashMap est que Hashtable est une classe obsolète et que vous devez utiliser ConcurrentHashMap au lieu de Hashtable en Java.

HashTable est une classe de legs dans le jdk qui ne devrait plus être utilisé. Remplacer usages of it with Competienthashmap . Si vous n'avez pas besoin de la sécurité du thread, 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 iterator dans le HashMap est infaillible tandis que l'enquêteur pour le Hashtable ne l'est pas. Si vous changez la carte en itérant, vous le saurez.

3) HashMap permet des valeurs nulles, alors que Hashtable ne le permet pas.

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

table de hachage:-C'est un héritage de la classe qui est reconnu à l'intérieur de cadre pour la collecte des

Hashtable:

Hashtable est une structure de données qui conserve les valeurs de la paire de valeurs clés. Il ne permet pas null à la fois 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 au 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:

table de hachage est comme table de hachage mais il accepte aussi la valeur de la clé de paire. Il permet null pour les clés et les valeurs. Son meilleur rendement est meilleur que HashTable , car il 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 HashTable

• 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 tous deux la collection basée sur le hash. et de travail sur le hachage. ce sont donc des similitudes de HashMap et de HashTable.

• Quelle est la différence entre HashMap et HashTable?

1) la première différence est que HashMap n'est pas sûr du fil tandis que HashTable est ThreadSafe

2) HashMap est plus performant car il n'est pas sûr. tandis que la performance Hashtable Sage n'est pas meilleure parce qu'il est sûr de fil. ainsi, le thread multiple ne peut pas accéder au 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 en GWT client code alors que Hashtable ne l'est pas.

"151910920 de Synchronisation" ou " Thread-Safe :

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

clés nulles et valeurs nulles :

HashMap permet une clé nulle et n'importe quel nombre de valeurs nulles.Hashtable ne permet pas null des clés ou des valeurs.

itérant les valeurs :

Itérateur dans la table de hachage est un fail-fast itérateur tandis que l'agent recenseur pour la table de hachage n'est pas et de le jeter ConcurrentModificationException si un autre Thread modifie la carte structurellement par l'ajout ou la suppression de tout élément à l'exception Itérateur propre méthode remove ().

super-classe et Héritage :

HashMap is la sous-classe de la classe AbstractMap tandis que le Hashtable est la sous-classe de la classe du dictionnaire.

Performance :

Comme table de hachage n'est pas synchronisé, il est plus rapide par rapport à la table de hachage.

Consultez http://modernpathshala.com/Article/1020/difference-between-hashmap-and-hashtable-in-java pour des exemples et des questions d'entrevue et questionnaire lié à Java collection