java example util - Différences entre HashMap et Hashtable?





15 Answers

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);
put open classroom

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

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




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




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.




Regardez 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 collection Java




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.




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?




HashMap et Hashtable présentent également des différences algorithmiques significatives. Personne n’en ayant déjà parlé, c’est la raison pour laquelle j’en parle. HashMap construira une table de hachage avec une taille de puissance deux, l'augmentera dynamiquement de manière à avoir au plus environ huit éléments (collisions) dans n'importe quel HashMap et HashMap très bien les éléments pour les types d'éléments généraux. Cependant, l’implémentation de Hashtable offre un contrôle plus précis et plus précis du hachage si vous savez ce que vous faites. En d’autres termes, 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 donnera de meilleures performances que HashMap, c’est-à-dire moins. des collisions dans certains cas.

À part les différences évidentes discutées de manière approfondie dans cette question, je considère la Hashtable comme une voiture à «entraînement manuel» où vous avez un meilleur contrôle du hachage et la HashMap comme l’équivalent «à l’entraînement automatique» qui fonctionnera généralement bien.




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.




Pour les applications à thread, vous pouvez souvent vous en sortir avec ConcurrentHashMap - cela dépend de vos exigences en matière de performances.




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

2. Hashmappeut stocker une clé comme null. Hashtablene peut pas stocker null.

3. HashMapn'est pas synchronisé mais Hashtableest synchronisé.

4. HashMappeut être synchronisé avecCollection.SyncronizedMap(map)

Map hashmap = new HashMap();

Map map = Collections.SyncronizedMap(hashmap);



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.




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.




Hashtable:

Hashtable est une structure de données qui conserve les valeurs de la paire clé-valeur. Il n'autorise pas la valeur null pour les clés et les valeurs. Vous obtiendrez un NullPointerExceptionsi vous ajoutez une valeur nulle. C'est synchronisé. Donc, cela vient 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 accepte également les paires de valeurs clés. Il autorise null pour les clés et les valeurs. Ses performances sont meilleures que HashTableparce qu’elles sont 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 donne la liberté de synchronisation et le débogage est beaucoup plus facile




Synchronisation ou thread sécurisé :

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

Clés nulles et valeurs nulles :

HashMap autorise une clé NULL et un nombre illimité de valeurs NULL. Hashtable n'autorise ni clés ni valeurs NULL.

Itérer les valeurs :

Iterator dans HashMap est un itérateur qui échoue rapidement tandis que l'énumérateur de Hashtable n'est 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.

Superclasse et Legacy :

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

Performance :

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

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




Related