Hashtable en java

Une table de hachage est pour les paires de clés / valeur. En interne, les valeurs sont stockées dans un tableau. Chaque clé est convertie en un indice du tableau. Cette conversion est connue sous le nom de hachage. Il est fait par une fonction de hachage en interne. En d'autres termes, les clés n'ont pas à être stockées. Tout ce qui est la table de hash, en java et dans d'autres langages informatiques. Cet article explique deux constructeurs du java hastable et ses méthodes couramment utilisées.

Les cinq lignes suivantes montrent des mots et leur signification:

accalmie: Pour rendre quelqu'un détendu et calme
Lumière: l'énergie du soleil
Daraille: absence de lumière
Papa: Un mot moins formel pour père
cuisinier: une personne dont le travail est de cuisiner

Chaque mot peut être considéré comme une clé, et chaque sens peut être considéré comme une valeur. Cette liste de paires de clés / valeur sera utilisée tout au long de cet article. La classe de hashtable est dans le java.user.* package, qui doit être importé.

Contenu de l'article

• Construction
• Accéder aux paires de clés / valeur
• Liste de retour de Hashtable
• Conversion de l'ensemble de paires de clés / valeur en chaîne
• Conclusion

Construction
HashTable public ()

Cette méthode construit une table de hachage vide. Le programme suivant crée un hachage vide, appelé DIC (pour Dictionary), puis lui donne cinq paires de clés / valeur.

Importer Java.user.*
classe publique TheClass
public static void main (String [] args)
Hachage dic = nouveau hashtable();
dic.mettre («accalmie», «rendre quelqu'un détendu et calme»); dic.mettre ("Light", "L'énergie du soleil");
dic.mettre ("obscurité", "absence de lumière"); dic.put ("papa", "un mot moins formel pour le père");
dic.mettre ("cuisiner", "une personne dont le travail est de cuisiner");

Notez que le type de clé doit être indiqué sur les côtés gauche et droit de l'instruction du constructeur. Le type de valeur doit également être indiqué des deux côtés. La classe de hashtable java a la méthode put () pour mettre une paire clé / valeur dans la table de hash.

hashtable public (carte t)

Cette méthode de constructeur créerait un hashtable à partir d'un autre hashtable. Le nom du hashtable du code ci-dessus est dic. Un autre hachage peut être créé à partir de DIC comme suit:

Hachage dic2 = nouveau hashtable(dic);

Le nouveau hashtable est dic2. Pour le moment, il a tous les éléments (paires de clés / valeur) du hachage DIC.

Accéder aux paires de clés / valeur
public v put (ke key, v valeur)

Cette méthode met une paire clé / valeur dans le hashtable. Il renvoie la valeur précédente de la clé spécifiée de ce hachage, ou null si la clé n'avait pas de valeur. Le code suivant illustre ceci:

Hachage hshtbl = nouveau hashtable();
String oldValue1 = hshtbl.mettre ("bleu", "avoir la couleur de la mer par une journée claire");
Système.dehors.println (OldValue1);
String oldvalue2 = hshtbl.mettre ("bleu", "couleur d'un ciel transparent par une journée claire");
Système.dehors.println (OldValue2);

La sortie est:

nul
Avoir la couleur de la mer par une journée claire

public void putall (carte t)

Cette méthode met un autre hachable dans le hashtable d'intérêt. Il revient vide. Imaginez que le hachage ci-dessus, DIC est déjà dans le programme. Imaginez qu'un autre hashtable, DIC3, avec le contenu suivant est également déjà dans le programme:

"bleu" = "Couleur d'un ciel transparent un jour clair",
"vector" = "un cours suivi par un avion"

Tout le contenu de DIC3 peut être inclus dans DIC, avec la déclaration suivante:

dic.putall (dic3);

public int size ()

Cette méthode renvoie le nombre de clés pour le hashtable. Le code suivant illustre ceci:

Hachage dic = nouveau hashtable();
dic.mettre («accalmie», «rendre quelqu'un détendu et calme»); dic.mettre ("Light", "L'énergie du soleil");
dic.mettre ("obscurité", "absence de lumière"); dic.put ("papa", "un mot moins formel pour le père");
dic.mettre ("cuisiner", "une personne dont le travail est de cuisiner");
int sz = dic.taille();
Système.dehors.println (sz);

La sortie est 5.

public v get (clé d'objet)

Cette méthode renvoie la valeur à laquelle la clé spécifiée a été hachée, ou null si la clé n'a été hachée à aucune valeur (index du tableau). Le code suivant illustre ceci:

Hachage dic = nouveau hashtable();
dic.mettre («accalmie», «rendre quelqu'un détendu et calme»); dic.mettre ("Light", "L'énergie du soleil");
dic.mettre ("obscurité", "absence de lumière"); dic.put ("papa", "un mot moins formel pour le père");
dic.mettre ("cuisiner", "une personne dont le travail est de cuisiner");
Système.dehors.println (dic.get ("accalmie"));
Système.dehors.println (dic.get ("Light"));
Système.dehors.println (dic.get ("vector"));

La sortie est:

Pour rendre quelqu'un détendu et calme
L'énergie du soleil
nul

public V Supprimer (clé d'objet)

Cette méthode supprime la clé et sa valeur correspondante, du hashtable. Il renvoie la valeur de la clé, ou null si la clé n'était pas présente, le code suivant l'illustre:

Hachage dic = nouveau hashtable();
dic.mettre («accalmie», «rendre quelqu'un détendu et calme»); dic.mettre ("Light", "L'énergie du soleil");
dic.mettre ("obscurité", "absence de lumière"); dic.put ("papa", "un mot moins formel pour le père");
dic.mettre ("cuisiner", "une personne dont le travail est de cuisiner");
String ret1 = dic.retirer ("obscurité");
String ret2 = dic.retirer ("obscurité");
Système.dehors.println (ret1);
Système.dehors.println (ret2);

La sortie est:

absence de lumière
nul

public booléen iSempty ()

Renvoie True si le hashtable n'a pas de clé de clés à une valeur (index du tableau); et faux sinon. Le code suivant montre comment utiliser cette méthode:

Hachage dic4 = nouveau hashtable();
booléen bl = dic4.est vide();
Système.dehors.println (BL);

La sortie est vraie.

public void clear ()

Cette méthode efface toutes les paires de clés / valeur dans le hashtable. La taille du hashtable devient nulle. Le code suivant montre son utilisation:

Hachage dic5 = nouveau hashtable();
dic5.mettre ("bleu", "couleur d'un ciel transparent par une journée claire");
dic5.put ("vecteur", "un cours suivi par un avion");
dic5.clair();
Système.dehors.println (dic5.taille());

La sortie est 0.

Liste de retour de Hashtable
Éléments de l'énumération publique ()

Cette méthode renvoie une énumération des valeurs du hashtable. La classe d'énumération a ses méthodes. Le code suivant montre comment obtenir une énumération des valeurs du hashtable et comment utiliser les méthodes d'énumération, pour lire les valeurs:

Hachage dic = nouveau hashtable();
dic.mettre («accalmie», «rendre quelqu'un détendu et calme»); dic.mettre ("Light", "L'énergie du soleil");
dic.mettre ("obscurité", "absence de lumière"); dic.put ("papa", "un mot moins formel pour le père");
dic.mettre ("cuisiner", "une personne dont le travail est de cuisiner");
Énumération e = dic.éléments();
Pendant que (e.HasmoreElements () == true)
String str = e.nextElement ();
Système.dehors.println (str);

La sortie est:

une personne dont le travail est de cuisiner
Un mot moins formel pour le père
L'énergie du soleil
absence de lumière
Pour rendre quelqu'un détendu et calme

Notez que l'ordre de sortie n'est pas l'ordre d'entrée. C'est ainsi que le hashtable dans Java fonctionne.

Keys d'énumération publique ()

Cette méthode renvoie une énumération des clés du hashtable. La classe d'énumération a ses méthodes. Le code suivant comment comment obtenir une énumération des clés du hashtable, et comment utiliser les méthodes d'énumération pour lire les clés:

Hachage dic = nouveau hashtable();
dic.mettre («accalmie», «rendre quelqu'un détendu et calme»); dic.mettre ("Light", "L'énergie du soleil");
dic.mettre ("obscurité", "absence de lumière"); dic.put ("papa", "un mot moins formel pour le père");
dic.mettre ("cuisiner", "une personne dont le travail est de cuisiner");
Énumération e = dic.clés();
Pendant que (e.HasmoreElements () == true)
String str = e.nextElement ();
Système.dehors.println (str);

La sortie est:

cuisiner
papa
lumière
obscurité
accalmie

Notez que l'ordre de sortie n'est pas l'ordre d'entrée. C'est ainsi que le hashtable dans Java fonctionne. La clé est en fait hachée à un index (nombre) d'un tableau, dont le contenu cellulaire est la valeur.

ensemble public entryset ()

Cette méthode renvoie une collection de visualités de paires de clés / valeur, du hashtable. Le code suivant montre comment gérer l'ensemble de retour, des paires de clés / valeur, et comment imprimer toutes les paires de clés / valeur:

Hachage dic = nouveau hashtable();
dic.mettre («accalmie», «rendre quelqu'un détendu et calme»); dic.mettre ("Light", "L'énergie du soleil");
dic.mettre ("obscurité", "absence de lumière"); dic.put ("papa", "un mot moins formel pour le père");
dic.mettre ("cuisiner", "une personne dont le travail est de cuisiner");
Ensemble> c = dic.entrySet ();
Itérateur> iter = c.iterator ();
tandis que (iter.hasnext () == true)
Carte.Entrée kv = iter.suivant();
Système.dehors.println (kv.getkey () + ":" + kv.getValue ());

La sortie est:

cuisinier: une personne dont le travail est de cuisiner
Papa: Un mot moins formel pour père
Lumière: l'énergie du soleil
Daraille: absence de lumière
accalmie: Pour rendre quelqu'un détendu et calme

Bien que les valeurs correspondantes pour les clés aient été maintenues, l'ordre de sortie n'est pas l'ordre d'entrée. C'est ainsi que le hashtable dans Java fonctionne.

Conversion de l'ensemble de paires de clés / valeur en chaîne
public String toString ()

Cette méthode convertit toutes les paires de clés / valeur du hashtable, en une longue chaîne. Peu importe, si les types de clés ou de valeurs n'étaient pas des chaînes. Ceci est illustré par le code suivant:

Hachage ht = nouveau hashtable();
HT.put ("dix", 10);
HT.put ("vingt", 20);
HT.put ("trente", 30);
String str = ht.toString ();
Système.dehors.println (str);

La sortie est:

vingt = 20, dix = 10, trente = 30

Conclusion

Une table de hash est une carte des paires de clés / valeur. En interne, une clé est en fait haché dans l'indice d'un tableau. La valeur de cet index est la valeur de la paire clé / valeur. Le hashtable est une classe dans le java.user.* Le package, qui doit être importé avant sa construction et d'autres méthodes, peut être utilisé.