Java hashset
Dans Java, un hashset est un ensemble. Alors qu'un ensemble serait un ensemble d'entiers, ou de flotteurs ou de cordes, etc., Le hashset serait un ensemble de paires. Dans Java proprement dit, une paire est une entrée de carte qui peut être créée indépendamment de la structure de données de type carte de destination. Une entrée de carte ou une paire est le code avec une clé et sa valeur correspondante. La clé est en fait hachée dans un index de tableau pour la valeur.
Ce qui suit est un exemple de données de paires de clés / valeur où une clé est un nom de fruit et la valeur correspondante est la couleur extérieure du fruit:
Fruit de la passion => violetpastèque => vert
pêche => jaune foncé
Papaya => Orange
mangue => jaune
Cet article fournit une connaissance de base de Java Hashset, en commençant par la création d'une paire (entrée de carte).
Création d'une entrée de carte
Une syntaxe pour créer une entrée de carte (paire) est:
public SimpleEntry (Key, Vale V)Ceci est de l'AbstractMap.Classe SimpleEntry, du package, Java.user.*, qui doit être importé. K est le type de clé, qui dans ce cas est une chaîne. V est le type de valeur, qui dans ce cas est toujours une chaîne.
Le segment de code suivant crée cinq paires:
AbstractMap.SimpleEntryAbstractMap.SimpleEntry
AbstractMap.SimpleEntry
AbstractMap.SimpleEntry
AbstractMap.SimpleEntry
Ces cinq paires peuvent former cinq éléments d'un hashset.
Construire un hashset
Il y a quatre constructeurs surchargés pour le hashset, mais seuls deux sont illustrés dans cet article.
Public Hashset ()
Cela crée un hashset vide. Un hashset vide pour les paires ci-dessus peut être créé comme suit:
HashsetHashset public (collection c)
Cela prend un autre hashset comme argument pour créer un nouveau hashset. Un exemple d'instruction de code d'un hashset créé à partir d'un autre hashset est:
Hashsetoù HS est un hashset déjà créé.
La classe de hashset est également dans le java.user.* package, qui doit être importé.
Méthodes du hashset
Les méthodes couramment utilisées de la classe Hashset sont expliquées dans cette section.
Public Boolean Add (E E)
Cela ajoute une nouvelle paire (élément) au hashset. Il renvoie True si cet ensemble ne contenait pas déjà l'élément spécifié; Faux autrement. Le segment de code suivant ajoute les cinq éléments (paires) ci-dessus au hashset, HS:
HashsetHS.ajouter (paire1); HS.ajouter (paire2); HS.ajouter (paire3); HS.ajouter (paire4); HS.ajouter (paire5);
public int size ()
Cela renvoie le nombre de paires (éléments) dans l'ensemble. Exemple:
int sz = hs.taille();Système.dehors.println (sz);
Pour ce code, la valeur de retour serait 5.
Iterator Iterator Iterator ()
Un itérateur est un objet qui peut être utilisé pour accéder à tous les éléments d'un ensemble (ou liste), un par un. L'instruction suivante renvoie un itérateur du hashset ci-dessus:
ItérateurL'itérateur a la méthode,
E suivant ()Cette méthode de l'itérateur renvoie l'élément suivant à partir du premier, dans l'ensemble (ou liste). Les éléments retournés ne sont pas nécessairement dans l'ordre dans lequel ils ont été ajoutés. Pour retourner l'élément suivant du hashset ci-dessus, l'instruction suivante peut être utilisée:
AbstractMap.SimpleEntryÀ gauche de l'opérateur d'affectation, est un nom décidé programmeur pour une paire (Map-Entry), paire, précédé du type de paire. À droite, l'itérateur est-il obtenu ci-dessus, suivi de la méthode, suivant (). Après le retour de la paire, les méthodes de la liste peuvent ensuite être utilisées pour gérer la paire.
La classe abstractmap.SimpleEntry, pour la paire, a la méthode, toString (). Cette méthode renvoie à la fois la clé et la valeur dans le formulaire de chaîne. Le segment de code suivant, imprime toutes les paires de touches / valeur du hashset ci-dessus à l'aide de l'itérateur:
pour (int i = 0; iSystème.dehors.println (paire.toString ());
La sortie est:
papaye = orangepêche = jaune foncé
mangue = jaune
pastèque = vert
Fruit de la passion = violet
La méthode sépare la clé de la valeur avec =.
Public Boolean Supprimer (objet O)
Cela supprime un élément (paire) que le programmeur sait déjà, devrait être présent, dans le hashset. Il revient vrai, si un changement a eu lieu; et faux sinon. L'itération et les classes de hashset ont cette méthode (légèrement différemment). Le segment de code suivant accède à tous les éléments du hashset et supprime «pastèque = vert».
pour (int i = 0; iString str = paire.toString ();
si (str.égaux ("pastèque = vert"))
iter.retirer();
Système.dehors.println (HS.taille());
La sortie est 4. La méthode retire () de l'itérateur et non celle du hashset a été utilisée. La paire (élément) à laquelle l'itérateur pointait a été supprimé.
public void clear ()
Cela supprime tous les éléments du hashset. Le segment de code suivant l'illustre:
HS.clair();Système.dehors.println (HS.taille());
La sortie est 0.
public booléen iSempty ()
Renvoie vrai, si le HashSet ne contient aucun élément, et faux sinon. Le code suivant l'illustre pour un ensemble non vide:
booléen bl = hs.est vide();Système.dehors.println (BL);
La sortie est fausse.
booléen contient (objet o)
Cela renvoie vrai, si le HashSet contient l'élément indiqué (paire); et faux sinon. Le segment de code suivant l'illustre pour un hashset qui a déjà des éléments:
AbstractMap.SimpleEntrybooléen bl = hs.contient (pairc);
Système.dehors.println (BL);
Pour le hashset ci-dessus, la sortie est vraie.
Conclusion
Le hashset en Java est un ensemble. Cependant, il diffère d'un ensemble normal, en ce que ses éléments devraient être des paires. Une paire est un code d'élément, qui a une clé et sa valeur correspondante. La clé est hachée à un index de tableau pour la valeur. L'instruction suivante créerait un hashset vide:
HashsetHS est le nom du hashset.
Dans Java proprement dit, une paire est une entrée de carte. L'énoncé suivant créerait une entrée de carte:
AbstractMap.SimpleEntryLe type de clé ici est une chaîne, et le type de valeur ici est également une chaîne.
La classe Java Hashset a des méthodes utiles qui ont été expliquées ci-dessus.