Hashtable en Java expliqué avec des exemples
La classe Java Hashtable crée une table de hachage en mappant des clés à des valeurs. Il implémente l'interface Map et l'hérite de la classe Dictionary.
Points à garder à l'esprit
- Une table de hachage est le tableau d'une liste.
- Chaque liste est appelée compartiment.
- La technique hashcode() est utilisée pour déterminer la position du bucket.
- Une table de hachage est une collection de valeurs basées sur une clé.
- La classe Hashtable en Java comporte des parties distinctes.
- La classe Hashtable en Java ne prend pas en charge les clés ou les valeurs nulles.
- La classe Hashtable en Java a été synchronisée.
- La capacité de la classe Hashtable est de 11 par défaut, alors que loadFactor est de 0,75.
Déclaration de la classe Hashtable
Examinons la déclaration de la classe java.util.Hashtable.
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable
Paramètres de classe dans une table de hachage
Regardons les paramètres de la classe java.util.Hashtable.
- Le type de touches de cette carte est désigné par la lettre K.
- V :il fait référence au type de valeur mappé.
Fonctionnement interne de Hashtable
Les paires clé/valeur sont stockées dans un tableau de compartiments de structure de données de table de hachage. La méthode hashCode() identifie le compartiment auquel la combinaison clé/valeur est mappée.
La fonction de hachage aide à identifier l'emplacement d'une clé dans la liste de compartiments. Le hashcode est un entier non négatif qui est égal pour des objets égaux mais qui peut ou non être égal pour des objets inégaux en général. La table de hachage utilise la méthode equals() pour déterminer si deux éléments sont égaux.
Deux objets inégaux peuvent avoir le même hashcode. Un tel cas est qualifié de collision. De plus, une table de hachage utilise un tableau de listes pour résoudre les collisions. Les paires qui correspondent à un compartiment unique (index de tableau) sont stockées dans une liste, et l'index de tableau contient une référence de liste.
Constructeurs de classe Java Hashtable
Table de hachage()
Il construit une table de hachage vide avec la capacité initiale et le facteur de charge définis par défaut.
Table de hachage (capacité int)
Il prend une entrée entière et génère une table de hachage avec une capacité initiale spécifique.
Hashtable (capacité int, float loadFactor)
Il est utilisé pour construire une table de hachage avec la capacité initiale et le loadFactor que vous spécifiez.
Hashtable(Carte t)
Il construit une nouvelle table de hachage avec les mêmes mappages que la carte.
Méthodes de classe Java Hashtable
annuler clear()
Il est utilisé pour effacer le contenu de la table de hachage.
Clone d'objet()
Il renvoie une table de hachage qui n'est qu'une réplique superficielle de l'original.
V calculate(K key, BiFunction remappingFunction)
Il est utilisé pour créer un mappage entre une clé et sa valeur mappée actuelle (ou null s'il n'y a pas de mappage actuel).
V computeIfAbsent(touche K, fonction mappingFunction)
Si la clé spécifiée n'est pas déjà associée à une valeur (ou est mappée sur null), elle est utilisée pour calculer sa valeur à l'aide de la fonction de mappage donnée et l'entre dans cette carte sauf si null.
V computeIfPresent(clé K, BiFunction remappingFunction)
Si la valeur de la clé spécifiée est présente et non nulle, elle est utilisée pour créer un nouveau mappage en fonction de la clé et de sa valeur mappée existante.
Éléments d'énumération()
Il vous donne une énumération des valeurs de la table de hachage.
Définir> entrySet()
Il vous donne une vue d'ensemble de tous les mappages sur la carte.
booléen égal à (Objet o)
Il est utilisé pour comparer l'Objet fourni et la Carte.
annuler pour chaque(action BiConsumer)
Il exécute l'action spécifiée pour chaque entrée de carte jusqu'à ce que toutes les entrées soient traitées ou que l'action lève une exception.
V getOrDefault(Clé d'objet, V defaultValue)
Il renvoie la valeur à laquelle la clé fournie est mappée ou defaultValue si aucun mappage pour la clé n'existe dans la carte.
int hashCode()
Il renvoie la valeur du code de hachage de la carte.
Clés d'énumération()
Il renvoie une énumération des clés de la table de hachage.
Définir keySet()
Il vous donne une vue Set des clés sur la carte.
Fusion V (touche K, valeur V, BiFunction remappingFunction)
Associe la clé fournie à la valeur non nulle si elle n'est pas déjà associée à une valeur ou est nulle.
V mis (touche K, valeur V)
Il ajoute la valeur fournie à la table de hachage avec la clé spécifiée.
void putAll(Carte t))
Il copie chaque paire clé-valeur de la carte vers la table de hachage.
V putIfAbsent(touche K, valeur V)
Si la clé spécifiée n'a pas encore de valeur (ou est mappée sur null), elle est associée à la valeur donnée et renvoie null ; sinon, il renvoie la valeur actuelle.
boolean remove(Object key, Object value)
Il efface la table de hachage des valeurs fournies et de leurs clés associées.
V remplace (touche K, valeur V)
Il substitue une clé spécifiée à la valeur fournie.
remplacement booléen (touche K, V ancienneValeur, V nouvelleValeur)
Une clé donnée remplace la valeur précédente par la nouvelle.
void replaceAll(BiFunction)
Jusqu'à ce que toutes les entrées aient été traitées ou que la fonction génère une erreur, elle remplace la valeur de chaque entrée par le résultat de l'exécution de la fonction spécifiée sur cette entrée.
Chaîne versChaîne()
Il renvoie la représentation sous forme de chaîne d'un objet Hashtable.
Valeurs de collecte()
Il vous donne une vue de collection de toutes les valeurs sur la carte.
booléen contient(Valeur de l'objet)
Si une valeur égale à la valeur existe dans la table de hachage, cette méthode renvoie true ; sinon, il renvoie faux.
booléen contientValeur(Valeur de l'objet)
Si la valeur est égale à quelque chose dans la table de hachage, cette méthode renvoie true; sinon, il renvoie faux.
boolean containsKey (clé d'objet)
Si une clé portant le même nom que la clé existe dans la table de hachage, cette méthode renvoie true ; sinon, il renvoie faux.
booléen isEmpty()
Si la table de hachage est vide, cette méthode renvoie true ; s'il a au moins une clé, il renvoie faux.
protégé void rehash()
Il est utilisé pour étendre la taille de la table de hachage et rehacher toutes ses clés.
V get(clé d'objet)
Cette méthode renvoie l'objet contenant la valeur correspondante de la clé.
V supprimer (clé d'objet)
Il est utilisé pour supprimer la clé et sa valeur. La valeur liée à la clé est retournée par cette méthode.
taille int()
Le nombre d'entrées dans la table de hachage est renvoyé par cette méthode.
Utilisation de Hashtable pour effectuer diverses opérations
Ajouter des éléments
La méthode put() ajoute un élément à la table de hachage. D'autre part, la table de hachage ne garde pas la trace de l'ordre d'insertion. En interne, chaque élément est généré avec un hachage différent et les éléments sont indexés en fonction de ce hachage pour améliorer l'efficacité.
// program for demonstrating how to add elements to a Hashtable in java
import java.io.*;
import java.util.*;
class CodeAddElementsToHashtable {
public static void main(String args[])
{
// it is needles mentioning the generic type twice
Hashtable<Integer, String> namesHashtable = new Hashtable<>();
// using Generics to initialize a Hashtable
Hashtable<Integer, String> languagesHashtable
= new Hashtable<Integer, String>();
// Inserting the Elements using the put() method
namesHashtable.put(1, "Green");
namesHashtable.put(2, "Mike");
namesHashtable.put(3, "Bright");
languagesHashtable.put(1, "Java");
languagesHashtable.put(2, "Python");
languagesHashtable.put(3, "Kotlin");
// Print the mappings to the console
System.out.println("Mappings of namesHashtable : " + namesHashtable);
System.out.println("Mappings of languagesHashtable : " + languagesHashtable);
}
}
Modification des éléments
Si nous voulons modifier un élément après son ajout, nous pouvons le faire en utilisant la méthode put () pour l'ajouter à nouveau. Étant donné que les clés sont utilisées pour indexer les éléments de la table de hachage, nous pouvons modifier la valeur de la clé en entrant simplement la valeur mise à jour de la clé que nous voulons modifier.
// program demonstrating how to update a Hashtable
import java.io.*;
import java.util.*;
class CodeUpdatesOnHashtable {
public static void main(String args[])
{
// Hashtable Initialization
Hashtable<Integer, String> namesHashtable
= new Hashtable<Integer, String>();
// Engaging the put method to insert new elements
namesHashtable.put(1, "Green");
namesHashtable.put(2, "Mike");
namesHashtable.put(3, "Bright");
// print the initial map to the console
System.out.println("The Original Hashtable is: " + namesHashtable);
// Update the value at the second key
namesHashtable.put(3, "Martin");
// print the updated map
System.out.println("The Updated Hashtable is: " + namesHashtable);
}
} Supprimer l'élément
La méthode remove() supprime un élément de la Map. Si une clé est présente sur la carte, cette méthode prend la valeur de la clé et supprime le mappage de cette clé de la carte.
// program for demonstrating the removal of mappings from the Hashtable
import java.io.*;
import java.util.*;
class CodeRemovingMappingsFromHashtable {
public static void main(String args[])
{
// Initialization of a Hashtable
Map<Integer, String> namesHashtable
= new Hashtable<Integer, String>();
// Engaging the put method to insert new elements
namesHashtable.put(1, "Green");
namesHashtable.put(2, "Mike");
namesHashtable.put(3, "Bright");
// Initial namesHashtable
System.out.println("The original namesHashtable is: " + namesHashtable);
// Remove the map entry with key 4
namesHashtable.remove(3);
// the final namesHashtable
System.out.println("The resultant updated namesHashtable : " + namesHashtable);
}
}
Parcourir une table de hachage
Nous pouvons utiliser une boucle for améliorée pour parcourir la table. L'itération d'une table de hachage est illustrée ci-dessous.
// program for illustrating the traversal of Hashtable in Java
import java.util.Hashtable;
import java.util.Map;
public class CodeIteratingHashtable {
public static void main(String[] args)
{
// Create a Hashtable object.
Hashtable<String, Integer> namesHashtable = new Hashtable<>();
// Using the put technique to add items
namesHashtable.put("Green", 33);
namesHashtable.put("Tyson", 16);
namesHashtable.put("White", 67);
// Using improved for loop iteration
for (Map.Entry<String, Integer> e : namesHashtable.entrySet())
System.out.println(e.getKey() + " "
+ e.getValue());
}
}
Exemple :table de hachage Java
import java.util.*;
class CodeHashtable{
public static void main(String args[]){
Hashtable<Integer,String> stringHashtable=new Hashtable<Integer,String>();
stringHashtable.put(1,"Bright");
stringHashtable.put(2,"Joy");
stringHashtable.put(3,"Esther");
stringHashtable.put(4,"Arnold");
for(Map.Entry myEntry:stringHashtable .entrySet()){
System.out.println(myEntry.getKey()+" "+myEntry .getValue());
}
}
} Exemple :méthode remove() de Java Hashtable
import java.util.*;
public class CodeHashtable {
public static void main(String args[]) {
Hashtable<Integer,String> nameHashtable=new Hashtable<Integer,String>();
nameHashtable.put(1,"Green");
nameHashtable.put(2,"Mike");
nameHashtable.put(3,"While");
nameHashtable.put(4,"Peter");
System.out.println("Hashtable before removal: "+ nameHashtable);
// Remove value for key 4
nameHashtable.remove(4);
System.out.println("Hashtable after removal: "+ nameHashtable);
}
} Exemple :Méthode Java Hashtable getOrDefault()
import java.util.*;
class CodeHashtableGetOrDefault{
public static void main(String args[]){
Hashtable<Integer,String> nameHashtable=new Hashtable<Integer,String>();
nameHashtable.put(1,"Green");
nameHashtable.put(2,"Mike");
nameHashtable.put(3,"While");
nameHashtable.put(4,"Peter");
// As method arguments, we specify the if and else statements.
System.out.println(nameHashtable .getOrDefault(2, "Not Found"));
System.out.println(nameHashtable .getOrDefault(4, "Not Found"));
}
} Exemple :la table de hachage putIfAbsent() de Java
import java.util.*;
class Hashtable4{
public static void main(String args[]){
Hashtable<Integer,String> nameHashtable=new Hashtable<Integer,String>();
nameHashtable.put(1,"Green");
nameHashtable.put(2,"Mike");
nameHashtable.put(3,"While");
nameHashtable.put(4,"Peter");
System.out.println("Initial nameHashtable : "+nameHashtable);
//Because the specified pair is unique, it inserts.
nameHashtable.putIfAbsent(2,"James");
System.out.println("Updated nameHashtable: "+nameHashtable);
//Because the specified pair already exists, this method returns the current value.
nameHashtable.putIfAbsent(4,"Tyson");
System.out.println("Updated nameHashtable: "+nameHashtable);
}
} Exemple :table de hachage de Java :site Web
import java.util.*;
class CodeWebsite {
int id;
String site_name,site_author,site_owner;
int site_links;
public CodeWebsite(int id, String site_ame, String site_author, String site_owner, int site_links) {
this.id = id;
this.site_name = site_name;
this.site_author = site_author;
this.site_owner = site_owner;
this.site_links = site_links;
}
}
public class CodeHashtable {
public static void main(String[] args) {
//Creating map of Books
Map<Integer,CodeWebsite> siteHashtable=new Hashtable<Integer,CodeWebsite>();
//Creating Books
CodeWebsite siteOne=new CodeWebsite(1,"codeunderscored.com","Brown","CodeUnderscored",200);
CodeWebsite siteTwo=new CodeWebsite(2,"Google.com","James","Google Inc.",200000);
CodeWebsite siteThree=new CodeWebsite(3,"Facebook","Wiley","Meta",100000);
//Adding CodeWebsite to siteHashtable
siteHashtable.put(1,siteOne);
siteHashtable.put(2,siteTwo);
siteHashtable.put(3,siteThree);
//Traversing the siteHashtable
for(Map.Entry<Integer, CodeWebsite> entry:siteHashtable .entrySet()){
int key=entry.getKey();
CodeWebsite new_site=entry.getValue();
System.out.println(key+" Details:");
System.out.println(new_site .id+" "+new_site .site_name+" "+new_site .site_author+" "+new_site .site_owner+" "+new_site .site_links);
}
}
} Conclusion
Une table de hachage est implémentée à l'aide de la classe Hashtable, qui mappe les clés aux valeurs. En tant que clé ou valeur, tout objet non nul peut être utilisé. Les objets utilisés comme clés doivent implémenter les méthodes hashCode et equals pour stocker et récupérer avec succès les objets d'une table de hachage.
