Comment utiliser Hashmap en Java
Banane => jaune
citron => jaune pâle
chaux => vert jaune
Kivi => vert
Avocat => vert
Raisin => violet
Fig => violet
=> - - - - -
=> - - - - -
=> - - - - -
La colonne de gauche a les clés, et la colonne à droite a les valeurs correspondantes. Notez que les fruits, Kivi et l'avocat ont la même couleur, vert. De plus, les fruits, les raisins et les figues ont la même couleur, violet. À la fin de la liste, trois emplacements attendent leurs propres couleurs. Ces emplacements n'ont pas de fruits correspondants; En d'autres termes, ces trois emplacements n'ont pas de clés correspondantes.
Tous les emplacements, qu'ils soient remplis ou non, à droite, sont appelés seaux. Pour chaque valeur, il y a une clé. Les clés sont uniques. Les valeurs ne doivent pas être uniques. C'est une relation plusieurs à un.
Ce qui est stocké dans le tableau est la bonne colonne. C'est-à-dire ce qui est stocké dans le tableau sont les valeurs. Les clés ne doivent pas être stockées. La clé est envoyée comme un argument à une fonction appelée fonction de hachage pour arriver à une valeur. La fonction de hachage produit l'indice correspondant associé à une valeur particulière.
Toute structure qui convient à toutes les descriptions ci-dessus est appelée un hachage. Avec le hashmap en java, les clés sont d'un type d'objet, et les valeurs sont d'un autre type d'objet. Il peut y avoir une clé nul, et il peut y avoir plus d'une valeur nulle.
La taille d'un hashmap est le nombre de paires de clés / valeur (entrées). La capacité d'un hashmap est le nombre de seaux, qu'il soit rempli ou non. La capacité doit toujours être supérieure à la taille.
Avec l'introduction ci-dessus, le lecteur peut maintenant apprendre à utiliser un hashmap à Java.
Contenu de l'article
- Construction
- Y compris les paires de clés / valeur
- Taille de hashmap
- Lire le hashmap
- Modification du hashmap
- Conclusion
Construction
Le hashmap est une classe à partir de laquelle un objet HashMap peut être créé. La création d'un objet à partir d'une classe est de construire l'objet. Il existe 4 façons de construire un hashmap en Java.
Facteur de charge
Le facteur de charge est le nombre de paires de clés / valeur divisées par le nombre de seaux.
Hashmap ()
Cette méthode de constructeur créerait un hashmap de capacité 16 et du facteur de charge 0.75. Cela signifie que le nombre de seaux sera de 16 (et vide), et le facteur de charge par défaut est 0.75. Après la création du hashmap, les paires de clés / valeur seront incluses. Dans ce cas, lorsque le nombre de paires de clés / valeur atteint 12, à 12/16 = 0.75, le hashmap remaniera automatiquement. Cela signifie qu'il augmentera automatiquement le nombre de seaux à 32 (double). Le code suivant montre comment créer un objet HashMap à l'aide de ce constructeur:
Importer Java.user.*classe theclass
public static void main (String [] args)
Hashmap hm = new hashmap ();
La classe Hashmap est en java.package util. Pour ce code, les clés seraient des chaînes et les valeurs seraient également des chaînes.
Hashmap (int initialCapacity)
Cela permet au programmeur de commencer avec une capacité différente mais toujours avec un facteur de charge de 0.75. Illustration:
Importer Java.user.*classe theclass
public static void main (String [] args)
Hashmap hm = new hashmap (20);
Donc, l'objet Hasmap commence ici avec 20 seaux vides. Ici, les clés sont des entiers. Ils diffèrent des index de tableau dans le sens où le premier index n'est pas nécessairement nul. De plus, les index ne sont pas contigus. Par exemple, le premier index peut-être 20; Le suivant est 35, celui après 52, etc.
Remarque: Avec le hashmap, la commande des paires de clé / valeur n'est pas maintenue. Autrement dit, si un ensemble de paires de clés / valeur est inclus dans un ordre, en affichant le contenu, la commande sera différente, bien que toutes les paires de clés / valeur incluses soient toujours là.
Les paires de clés / de valeur pour le hashmap sont mieux appelées mappages.
Hashmap (int initialCapacity, float chargefactor)
Ici, le facteur de chargement est également cité. Le facteur de charge est un type de flotteur et non un type entier. Ici, un facteur de charge différent de 0.75 est cité. Il y a des avantages et des inconvénients à avoir un facteur de charge qui diffère de 0.75 - Voir plus tard. Illustration:
Importer Java.user.*classe theclass
public static void main (String [] args)
Hashmap hm = new hashmap (20,0.62f);
Notez l'utilisation de «F» comme suffixe pour le facteur de charge.
Hashmap (carte m)
Ce constructeur créera un hashmap à partir d'une carte qui existe déjà - voir plus tard.
Y compris les paires de clés / valeur
put (clé k, valeur V)
Cette méthode relie une valeur particulière à une clé particulière. La clé est en fait haché dans un index directement associé à la valeur. Cependant, c'est le programmeur ou l'utilisateur qui décide de la valeur et de sa clé. L'exemple suivant crée un Hasmap, HM et comprend toutes les paires de clés / valeur et les seaux vides d'en haut:
classe theclass
public static void main (String [] args)
Hashmap hm = new hashmap (11);
HM.put ("Apple rouge", "rouge");
HM.put ("banane", "jaune");
HM.mettre ("citron", "jaune pâle");
HM.mettre ("chaux", "vert jaune");
HM.put ("kivi", "vert");
HM.put ("avocat", "vert");
HM.put ("raisin", "violet");
HM.put ("fig", "violet");
La capacité est 11. Le nombre de paires de clés / valeur est 8. Cela signifie que la taille est de 8. Ainsi, le facteur de charge effectif est 8/11 = 0.73F. Le nombre de seaux vides est de 11 - 8 = 3.
PUTIFABSENT (Key K, Vale V)
Cela inclut la paire de touches / valeur si la clé n'existe pas déjà dans le hashmap. Dans ce cas, la valeur de retour est nul. Si la clé existe déjà, rien ne change et l'ancienne valeur de la clé est renvoyée. Si le code suivant est ajouté au bas du code ci-dessus (dans main ()), alors la sortie serait nul:
Système.dehors.println (v);
Remarque: put (clé k, valeur V) déplacerait la paire clé / valeur pour la clé en question qui est déjà là, donnant effectivement une nouvelle valeur pour la clé.
Taille de hashmap
La taille du hashmap est le nombre de paires de clés / valeur.
taille()
L'énoncé suivant renverra la taille du hashmap:
est vide()
Cette méthode, renvoie vrai si le hashmap ne contient aucun mappage de valeur clé, ou faux sinon. Exemple:
Système.dehors.println (BL);
Un hashmap vide peut avoir des seaux vides.
Lire le hashmap
get (clé d'objet)
Renvoie (copie) la valeur correspondant à la clé; ou renvoie null s'il n'y a pas de valeur correspondante. Exemple:
Système.dehors.println (str);
contientyKey (clé d'objet)
Renvoie True s'il existe un mappage pour cette clé particulière; Faux autrement. Exemple:
contientValue (valeur de l'objet)
Renvoie True s'il existe un mappage pour cette valeur; Faux autrement. Exemple:
keyset ()
Cette méthode renvoie toutes les clés des paires de clés / valeur. Exemple de code:
pour (String Val: ST)
Système.dehors.print (val + ",");
Système.dehors.println ();
Notez que l'objet de retour est un ensemble. Si le hashmap d'origine ci-dessus est utilisé, la sortie serait:
citron, kivi, figue, raisin, citron vert, avocat, pomme rouge, banane,Notez que l'ordre n'est pas l'ordre dans lequel les clés ont été incluses.
valeurs()
Cette méthode renvoie une collection de toutes les valeurs du hashmap. Exemple de code:
pour (String Val: CL)
Système.dehors.print (val + ",");
Système.dehors.println ();
Notez que l'objet de retour est une collection. Si le hashmap d'origine ci-dessus est utilisé, la sortie serait:
Jaune pâle, vert, violet, violet, jaune-vert, vert, rouge, jaune,Notez que l'ordre n'est pas l'ordre dans lequel les valeurs ont été incluses.
entryset ()
Cela renvoie toutes les paires de clés / valeur, mais le programmeur doit séparer chaque clé de sa valeur correspondante. Exemple de code:
pour (carte.Entrée KV: STM)
Système.dehors.println (kv.getKey () + "=>" + kv.getValue ());
Si le hashmap d'origine ci-dessus est utilisé, la sortie serait:
citron => jaune pâleKivi => vert
Fig => violet
Raisin => violet
chaux => vert jaune
Avocat => vert
Apple rouge => rouge
Banane => jaune
Notez que l'ordre n'est pas l'ordre dans lequel les paires de clés / valeur ont été incluses.
Modification du hashmap
put (clé k, valeur V)
La méthode put () est similaire à la méthode putifabsent () en ce que si la clé existe déjà, l'ancienne valeur est renvoyée, et si la clé n'existe pas déjà, null est renvoyé. N'oubliez pas que put () remplace l'ancienne valeur si la clé existe déjà. Si la clé n'existe pas déjà, put () inclut la nouvelle entrée (paire de clé / valeur).
remplacer (clé k, valeur V)
Pour une clé qui est déjà en place, cette méthode est utilisée pour remplacer la valeur de la clé correspondante. Le hashmap est une structure plusieurs à un. Un exemple de code pour le hashmap ci-dessus est:
Système.dehors.println (v);
String str = hm.obtenir ("banane");
Système.dehors.println (str);
La sortie est:
jauneblanc
La méthode Remplace () renvoie l'ancienne valeur. Si la clé n'existe pas, elle renvoie nul et rien n'est remplacé.
Remplacer (Key K, v OldValue, v newValue)
Cela permet le remplacement d'une valeur particulière que le programmeur est consciente. Il revient vrai s'il a réussi et faux si ce n'est pas. Un exemple de code pour l'objet HashMap ci-dessus est:
Système.dehors.println (BL);
supprimer (touche d'objet)
Cela supprime la paire clé / valeur mappée par la clé. Il renvoie la valeur correspondante supprimée. Il renvoie null si la clé n'était pas présente. Un exemple de code pour le hashmap ci-dessus est:
Système.dehors.println (v);
supprimer (touche d'objet, valeur de l'objet)
Cela permet de supprimer une entrée (paire de clés / valeur) pour une valeur particulière que le programmeur est conscient. Il revient vrai s'il a réussi et faux si ce n'est pas. Un exemple de code pour l'objet HashMap ci-dessus est:
Système.dehors.println (BL);
Conclusion
Un tableau peut être considéré comme une cartographie des index vers les valeurs (d'un type particulier). Un hashmap doit être utilisé lorsque le mappage d'un type d'objet à un autre type d'objet est nécessaire. De cette façon, il y a des paires de clés / de valeur. Un hachage est une structure de données où le nombre de valeurs est limité, mais le nombre de clés possibles est supérieur au nombre de valeurs possibles. Et donc les clés doivent être hachés pour arriver aux valeurs. Java Hashmap pour sa fonction de hachage implicite a été présentée ci-dessus. Le programmeur peut écrire sa propre fonction de hachage (cartographie). Cependant, c'est un sujet pour une autre fois.
Chrys