Le Table de hachage La classe implémente une table de hachage, qui mappe les clés aux valeurs. Tout objet non nul peut être utilisé comme clé ou comme valeur. Pour réussir à stocker et récupérer des objets d'une table de hachage, les objets utilisés comme clés doivent implémenter la méthode hashCode et la méthode equals.
La classe java.util.Hashtable est une classe en Java qui fournit une structure de données clé-valeur, similaire à l'interface Map. Il faisait partie du framework Java Collections d'origine et a été introduit dans Java 1.0.
Cependant, la classe Hashtable a depuis été considérée comme obsolète et son utilisation est généralement déconseillée. En effet, il a été conçu avant l'introduction du framework Collections et n'implémente pas l'interface Map, ce qui rend difficile son utilisation avec d'autres parties du framework. De plus, la classe Hashtable est synchronisée, ce qui peut entraîner des performances plus lentes par rapport aux autres implémentations de l'interface Map.
En général, il est recommandé d'utiliser l'interface Map ou l'une de ses implémentations (telle que HashMap ou ConcurrentHashMap) au lieu de la classe Hashtable.
Voici un exemple d’utilisation de la classe Hashtable :
Java
import> java.util.Enumeration;> import> java.util.Hashtable;> public> class> Main {> >public> static> void> main(String[] args) {> >Hashtable hashtable =>new> Hashtable();> >// Adding elements to the hashtable> >hashtable.put(>'A'>,>1>);> >hashtable.put(>'B'>,>2>);> >hashtable.put(>'C'>,>3>);> >// Getting values from the hashtable> >int> valueA = hashtable.get(>'A'>);> >System.out.println(>'Value of A: '> + valueA);> >// Removing elements from the hashtable> >hashtable.remove(>'B'>);> >// Enumerating the elements of the hashtable> >Enumeration keys = hashtable.keys();> >while> (keys.hasMoreElements()) {> >String key = keys.nextElement();> >System.out.println(>'Key: '> + key +>', Value: '> + hashtable.get(key));> >}> >}> }> |
>
>Sortir
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
En conclusion, même si la classe Hashtable existe toujours en Java et peut toujours être utilisée, il est généralement recommandé d’utiliser plutôt l’interface Map ou l’une de ses implémentations.
Caractéristiques de la table de hachage
- Il est similaire à HashMap, mais est synchronisé.
- Hashtable stocke la paire clé/valeur dans la table de hachage.
- Dans Hashtable, nous spécifions un objet utilisé comme clé et la valeur que nous souhaitons associer à cette clé. La clé est ensuite hachée et le code de hachage résultant est utilisé comme index auquel la valeur est stockée dans la table.
- La capacité initiale par défaut de la classe Hashtable est de 11 alors que loadFactor est de 0,75.
- HashMap ne fournit aucune énumération, tandis que Hashtable ne fournit pas d'énumération rapide.
Déclaration:
public class Hashtable extends Dictionary implements Map, Cloneable, Serializable>
Paramètres de type :
- K – le type de clés maintenues par cette carte
- DANS – le type de valeurs mappées
La hiérarchie des tables de hachage
Implémentations de table de hachage Sérialisable , Clonable , Carte interfaces et extensions Dictionnaire . Les sous - classes directes sont Properties , UIDefaults .
Constructeurs :
Afin de créer une table de hachage, nous devons l'importer depuis java.util.Hashtable . Il existe différentes manières de créer une table de hachage.
1. Table de hachage() : Cela crée une table de hachage vide avec le facteur de charge par défaut de 0,75 et une capacité initiale de 11.
Table de hachage ht = new Hashtable();
Java
// Java program to demonstrate> // adding elements to Hashtable> import> java.io.*;> import> java.util.*;> class> AddElementsToHashtable {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Hashtable ht1 =>new> Hashtable();> >// Initialization of a Hashtable> >// using Generics> >Hashtable ht2> >=>new> Hashtable();> >// Inserting the Elements> >// using put() method> >ht1.put(>1>,>'one'>);> >ht1.put(>2>,>'two'>);> >ht1.put(>3>,>'three'>);> >ht2.put(>4>,>'four'>);> >ht2.put(>5>,>'five'>);> >ht2.put(>6>,>'six'>);> >// Print mappings to the console> >System.out.println(>'Mappings of ht1 : '> + ht1);> >System.out.println(>'Mappings of ht2 : '> + ht2);> >}> }> |
>
>Sortir
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 2. Table de hachage (int initialCapacity) : Cela crée une table de hachage dont la taille initiale est spécifiée par initialCapacity et le facteur de charge par défaut est de 0,75.
Table de hachage ht = new Hashtable(int initialCapacity);
Java
// Java program to demonstrate> // adding elements to Hashtable> import> java.io.*;> import> java.util.*;> class> AddElementsToHashtable {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Hashtable ht1 =>new> Hashtable(>4>);> >// Initialization of a Hashtable> >// using Generics> >Hashtable ht2> >=>new> Hashtable(>2>);> >// Inserting the Elements> >// using put() method> >ht1.put(>1>,>'one'>);> >ht1.put(>2>,>'two'>);> >ht1.put(>3>,>'three'>);> >ht2.put(>4>,>'four'>);> >ht2.put(>5>,>'five'>);> >ht2.put(>6>,>'six'>);> >// Print mappings to the console> >System.out.println(>'Mappings of ht1 : '> + ht1);> >System.out.println(>'Mappings of ht2 : '> + ht2);> >}> }> |
>
>Sortir
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {4=four, 6=six, 5=five}> 3. Table de hachage (taille int, float fillRatio) : Cette version crée une table de hachage qui a une taille initiale spécifiée par size et un taux de remplissage spécifié par fillRatio. taux de remplissage : essentiellement, il détermine le niveau de remplissage d'une table de hachage avant qu'elle ne soit redimensionnée vers le haut et sa valeur est comprise entre 0,0 et 1,0.
Hashtable ht = new Hashtable (int size, float fillRatio);
Java
// Java program to demonstrate> // adding elements to Hashtable> import> java.io.*;> import> java.util.*;> class> AddElementsToHashtable {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Hashtable ht1> >=>new> Hashtable(>4>,>0>.75f);> >// Initialization of a Hashtable> >// using Generics> >Hashtable ht2> >=>new> Hashtable(>3>,>0>.5f);> >// Inserting the Elements> >// using put() method> >ht1.put(>1>,>'one'>);> >ht1.put(>2>,>'two'>);> >ht1.put(>3>,>'three'>);> >ht2.put(>4>,>'four'>);> >ht2.put(>5>,>'five'>);> >ht2.put(>6>,>'six'>);> >// Print mappings to the console> >System.out.println(>'Mappings of ht1 : '> + ht1);> >System.out.println(>'Mappings of ht2 : '> + ht2);> >}> }> |
>
>Sortir
Mappings of ht1 : {3=three, 2=two, 1=one} Mappings of ht2 : {6=six, 5=five, 4=four}> 4. Table de hachage (Carte m) : Cela crée une table de hachage initialisée avec les éléments en m.
Table de hachage ht = nouvelle table de hachage (Carte m);
Java
// Java program to demonstrate> // adding elements to Hashtable> import> java.io.*;> import> java.util.*;> class> AddElementsToHashtable {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Map hm =>new> HashMap();> >// Inserting the Elements> >// using put() method> >hm.put(>1>,>'one'>);> >hm.put(>2>,>'two'>);> >hm.put(>3>,>'three'>);> >// Initialization of a Hashtable> >// using Generics> >Hashtable ht2> >=>new> Hashtable(hm);> >// Print mappings to the console> >System.out.println(>'Mappings of ht2 : '> + ht2);> >}> }> |
>
>Sortir
Mappings of ht2 : {3=three, 2=two, 1=one}> Exemple:
Java
// Java program to illustrate> // Java.util.Hashtable> import> java.util.*;> public> class> GFG {> >public> static> void> main(String[] args)> >{> >// Create an empty Hashtable> >Hashtable ht =>new> Hashtable();> >// Add elements to the hashtable> >ht.put(>'vishal'>,>10>);> >ht.put(>'sachin'>,>30>);> >ht.put(>'vaibhav'>,>20>);> >// Print size and content> >System.out.println(>'Size of map is:- '> + ht.size());> >System.out.println(ht);> >// Check if a key is present and if> >// present, print value> >if> (ht.containsKey(>'vishal'>)) {> >Integer a = ht.get(>'vishal'>);> >System.out.println(>'value for key'> >+>' 'vishal' is:- '> + a);> >}> >}> }> |
>
>Sortir
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> Effectuer diverses opérations sur Hashtable
1. Ajout d'éléments : Afin d'ajouter un élément à la table de hachage, nous pouvons utiliser la méthode put(). Cependant, l'ordre d'insertion n'est pas conservé dans la table de hachage. En interne, pour chaque élément, un hachage distinct est généré et les éléments sont indexés en fonction de ce hachage pour le rendre plus efficace.
Java
// Java program to demonstrate> // adding elements to Hashtable> import> java.io.*;> import> java.util.*;> class> AddElementsToHashtable {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Hashtable ht1 =>new> Hashtable();> >// Initialization of a Hashtable> >// using Generics> >Hashtable ht2> >=>new> Hashtable();> >// Inserting the Elements> >// using put() method> >ht1.put(>1>,>'Geeks'>);> >ht1.put(>2>,>'For'>);> >ht1.put(>3>,>'Geeks'>);> >ht2.put(>1>,>'Geeks'>);> >ht2.put(>2>,>'For'>);> >ht2.put(>3>,>'Geeks'>);> > >// Print mappings to the console> >System.out.println(>'Mappings of ht1 : '> + ht1);> >System.out.println(>'Mappings of ht2 : '> + ht2);> >}> }> |
>
>Sortir
Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks} Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}> 2. Modification des éléments : Après avoir ajouté les éléments, si nous souhaitons modifier l'élément, cela peut être fait en ajoutant à nouveau l'élément avec la méthode put(). Étant donné que les éléments de la table de hachage sont indexés à l'aide des clés, la valeur de la clé peut être modifiée en insérant simplement la valeur mise à jour pour la clé pour laquelle nous souhaitons modifier.
Java
// Java program to demonstrate> // updating Hashtable> import> java.io.*;> import> java.util.*;> class> UpdatesOnHashtable {> >public> static> void> main(String args[])> >{> >// Initialization of a Hashtable> >Hashtable ht> >=>new> Hashtable();> >// Inserting the Elements> >// using put method> >ht.put(>1>,>'Geeks'>);> >ht.put(>2>,>'Geeks'>);> >ht.put(>3>,>'Geeks'>);> > >// print initial map to the console> >System.out.println(>'Initial Map '> + ht);> > >// Update the value at key 2> >ht.put(>2>,>'For'>);> > >// print the updated map> >System.out.println(>'Updated Map '> + ht);> >}> }> |
>
>Sortir
Initial Map {3=Geeks, 2=Geeks, 1=Geeks} Updated Map {3=Geeks, 2=For, 1=Geeks}> 3. Suppression d'un élément : Afin de supprimer un élément de la Map, nous pouvons utiliser la méthode remove(). Cette méthode prend la valeur de la clé et supprime le mappage d'une clé de cette carte si elle est présente dans la carte.
Java
// Java program to demonstrate> // the removing mappings from Hashtable> import> java.io.*;> import> java.util.*;> class> RemovingMappingsFromHashtable {> >public> static> void> main(String args[])> >{> >// Initialization of a Hashtable> >Map ht> >=>new> Hashtable();> >// Inserting the Elements> >// using put method> >ht.put(>1>,>'Geeks'>);> >ht.put(>2>,>'For'>);> >ht.put(>3>,>'Geeks'>);> >ht.put(>4>,>'For'>);> >// Initial HashMap> >System.out.println(>'Initial map : '> + ht);> >// Remove the map entry with key 4> >ht.remove(>4>);> >// Final Hashtable> >System.out.println(>'Updated map : '> + ht);> >}> }> |
>
>Sortir
Initial map : {4=For, 3=Geeks, 2=For, 1=Geeks} Updated map : {3=Geeks, 2=For, 1=Geeks}> 4. Parcours d'une table de hachage : Pour parcourir le tableau, nous pouvons utiliser un boucle for avancée . Vous trouverez ci-dessous un exemple d'itération d'une table de hachage.
Java
// Java program to illustrate> // traversal of Hashtable> import> java.util.Hashtable;> import> java.util.Map;> public> class> IteratingHashtable {> >public> static> void> main(String[] args)> >{> >// Create an instance of Hashtable> >Hashtable ht =>new> Hashtable();> >// Adding elements using put method> >ht.put(>'vishal'>,>10>);> >ht.put(>'sachin'>,>30>);> >ht.put(>'vaibhav'>,>20>);> > >// Iterating using enhanced for loop> >for> (Map.Entry e : ht.entrySet())> >System.out.println(e.getKey() +>' '> >+ e.getValue());> >}> }> |
chaîne formatée en c
>
>Sortir
vaibhav 20 vishal 10 sachin 30>
Fonctionnement interne de la table de hachage
La structure de données de table de hachage est un tableau de compartiments qui y stockent les paires clé/valeur. Il utilise Méthode hashCode() pour déterminer quel compartiment la paire clé/valeur doit mapper.
La fonction de hachage permet de déterminer l'emplacement d'une clé donnée dans la liste de compartiments. Généralement, le hashcode est un entier non négatif qui est égal pour des objets égaux et peut ou non être égal pour des objets inégaux. Pour déterminer si deux objets sont égaux ou non, hashtable utilise la méthode equals().
Il est possible que deux Objets inégaux aient le même hashcode. C'est ce qu'on appelle un collision . Pour résoudre les collisions, hashtable utilise un tableau de listes. Les paires mappées sur un seul compartiment (index de tableau) sont stockées dans une liste et la référence de liste est stockée dans l'index de tableau.
Méthodes de table de hachage
- K – Le type des clés dans la carte.
- DANS – Le type de valeurs mappées dans la carte.
| MÉTHODE | DESCRIPTION |
|---|---|
| clair() | Efface cette table de hachage afin qu'elle ne contienne aucune clé. |
| cloner() | Crée une copie superficielle de cette table de hachage. |
| calculer (touche K, BiFunction K,? super V? étend V> remappageFonction) | Tente de calculer un mappage pour la clé spécifiée et sa valeur mappée actuelle (ou null s'il n'y a pas de mappage actuel). |
| calculateIfAbsent (touche K, fonction étend V> mappingFunction) | Si la clé spécifiée n'est pas déjà associée à une valeur (ou est mappée à null), tente de calculer sa valeur à l'aide de la fonction de mappage donnée et l'entre dans cette carte sauf si null. |
| calculateIfPresent (touche K, fonction de remapping BiFunction) | Si la valeur de la clé spécifiée est présente et non nulle, tente de calculer un nouveau mappage en fonction de la clé et de sa valeur mappée actuelle. |
| contient (valeur de l'objet) | Teste si certaines clés correspondent à la valeur spécifiée dans cette table de hachage. |
| contientClé (clé d'objet) | Teste si l'objet spécifié est une clé dans cette table de hachage. |
| contientValeur(Valeur de l'objet) | Renvoie vrai si cette table de hachage mappe une ou plusieurs clés à cette valeur. |
| éléments() | Renvoie une énumération des valeurs de cette table de hachage. |
| jeu d'entrées() | Renvoie une vue Set des mappages contenus dans cette carte. |
| est égal à (Objet o) | Compare l'objet spécifié avec cette carte pour l'égalité, selon la définition dans l'interface Map. |
| obtenir (clé d'objet) | Renvoie la valeur à laquelle la clé spécifiée est mappée, ou null si cette carte ne contient aucun mappage pour la clé. |
| code de hachage() | Renvoie la valeur du code de hachage pour cette carte selon la définition dans l'interface Map. |
| est vide() | Teste si cette table de hachage ne mappe aucune clé à des valeurs. |
| clés() | Renvoie une énumération des clés de cette table de hachage. |
| jeu de clés() | Renvoie une vue Set des clés contenues dans cette carte. |
| fusionner (clé K, valeur V, fonction de remappage BiFunction) | Si la clé spécifiée n'est pas déjà associée à une valeur ou est associée à null, l'associe à la valeur non nulle donnée. |
| mettre (clé K, valeur V) | Mappe la clé spécifiée à la valeur spécifiée dans cette table de hachage. |
| putAll (Carte t) | Copie tous les mappages de la carte spécifiée vers cette table de hachage. |
| répéter() | Augmente la capacité et réorganise en interne cette table de hachage, afin d'accueillir et d'accéder plus efficacement à ses entrées. |
| supprimer(clé d'objet) | Supprime la clé (et sa valeur correspondante) de cette table de hachage. |
| taille() | Renvoie le nombre de clés dans cette table de hachage. |
| àChaîne() | Renvoie une représentation sous forme de chaîne de cet objet Hashtable sous la forme d'un ensemble d'entrées, entourées d'accolades et séparées par les caractères ASCII (virgule et espace). |
| valeurs() | Renvoie une vue Collection des valeurs contenues dans cette carte. |
Méthodes déclarées dans l'interface java.util.Map
| MÉTHODE | DESCRIPTION |
|---|---|
| pourEach (action BiConsumer) | Exécute l'action donnée pour chaque entrée de cette carte jusqu'à ce que toutes les entrées aient été traitées ou que l'action lève une exception. |
| getOrDefault (clé objet, V valeur par défaut) | Renvoie la valeur à laquelle la clé spécifiée est mappée, ou defaultValue si cette carte ne contient aucun mappage pour la clé. |
| putIfAbsent(clé K, valeur V) | Si la clé spécifiée n'est pas déjà associée à une valeur (ou est mappée à null), l'associe à la valeur donnée et renvoie null, sinon renvoie la valeur actuelle. |
| supprimer(clé d'objet, Valeur de l'objet) | Supprime l'entrée pour la clé spécifiée uniquement si elle est actuellement mappée à la valeur spécifiée. |
| remplacer (clé K, valeur V) | Remplace l'entrée pour la clé spécifiée uniquement si elle est actuellement mappée à une valeur. |
| remplacer (clé K, V oldValue, V newValue) | Remplace l'entrée pour la clé spécifiée uniquement si elle est actuellement mappée à la valeur spécifiée. |
| replaceAll (fonction BiFunction) | Remplace la valeur de chaque entrée par le résultat de l'appel de la fonction donnée sur cette entrée jusqu'à ce que toutes les entrées aient été traitées ou que la fonction lève une exception. |
Doit lire:
- Différences entre HashMap et HashTable en Java
Avantages de la table de hachage :
- Thread-safe : la classe Hashtable est thread-safe, ce qui signifie que plusieurs threads peuvent y accéder simultanément sans provoquer de corruption des données ou d'autres problèmes de synchronisation.
- Simple à utiliser : la classe Hashtable est simple à utiliser et fournit des fonctionnalités de base de structure de données clé-valeur, qui peuvent être utiles pour des cas simples.
Inconvénients de la table de hachage :
- Obsolète : La classe Hashtable est considérée comme obsolète et son utilisation est généralement déconseillée. En effet, il a été conçu avant l'introduction du framework Collections et n'implémente pas l'interface Map, ce qui rend difficile son utilisation avec d'autres parties du framework.
- Fonctionnalité limitée : la classe Hashtable fournit des fonctionnalités de base de structure de données clé-valeur, mais ne fournit pas la gamme complète de fonctionnalités disponibles dans l'interface Map et ses implémentations.
- Mauvaises performances : la classe Hashtable est synchronisée, ce qui peut entraîner des performances plus lentes par rapport à d'autres implémentations de l'interface Map, telles que HashMap ou ConcurrentHashMap.
Livres de référence:
- Collections Java de Maurice Naftalin et Philip Wadler. Ce livre fournit une présentation complète du framework Java Collections, y compris la classe Hashtable.
- Java en bref par David Flanagan. Ce livre fournit une référence rapide sur les fonctionnalités principales de Java, y compris la classe Hashtable.
- Génériques et collections Java par Maurice Naftalin et Philip Wadler. Ce livre fournit un guide complet des génériques et des collections en Java, y compris la classe Hashtable.
Référence: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html