Java

HashSet en Java - java.util.HashSet

Les listes et LinketList vous permettent de spécifier l'ordre dans lequel vous souhaitez organiser les éléments. Toutefois, si vous recherchez un élément en particulier et que vous ne vous souvenez pas de sa position, vous devez visiter tous les éléments jusqu'à ce que vous trouviez une correspondance. Cela peut prendre beaucoup de temps si la collection contient de nombreux éléments. Si vous ne vous souciez pas de l'ordre des éléments, il existe des structures de données qui vous permettent de trouver les éléments beaucoup plus rapidement.

L'inconvénient est que ces structures de données ne vous permettent pas de contrôler l'ordre dans lequel les éléments apparaissent. Ces structures de données organisent les éléments dans un ordre adapté à leurs besoins.

Une structure de données bien connue pour trouver des objets rapidement est la table de hachage (HashTable). Une table de hachage calcule un entier, appelé le code de hachage pour chaque objet. Un code de hachage est en quelque sorte dérivé des champs d'instance d'un objet, de préférence de telle sorte que les objets avec des données différentes génèrent des codes différents.

En Java, les tables de hachage sont implémentées en tant que tableaux de listes chaînées (LinkedList). Chaque liste s'appelle une alvéole (en anglais, buckets ou slots).

 Remarque !  à partir de Java 8, les slots ne sont plus des listes chaînées, mais deviennent des arbres binaires équilibrés lorsqu'ils sont pleins. Cela améliore les performances si une fonction de hachage est mal choisie et génère de nombreuses collisions ou si un code malveillant tente d'inonder une table de hachage de nombreuses valeurs ayant des codes de hachage identiques

La bibliothèque Collections Java fournit une classe HashSet qui implémente un Set basé sur une table de hachage (HashTable).

Voici la liste des constructeurs fournis par la classe HashSet.

ConstructeurDescription
HashSet()Ce constructeur construit un HashSet par défaut.
HashSet(Collection c)Ce constructeur initialise le hash set en utilisant les éléments de la collection c.
HashSet(int capacity)Ce constructeur initialise la capacité du hachage défini sur la valeur entière donnée. La capacité augmente automatiquement à mesure que des éléments sont ajoutés au HashSet.
HashSet(int capacity, float fillRatio)Ce constructeur initialise à la fois la capacité et le taux de remplissage (load capacity) de HashSet à partir de ses arguments.
Ici, le taux de remplissage doit se situer entre 0,0 et 1,0, et il détermine la quantité de HashSet avant de le redimensionner vers le haut. Plus précisément, lorsque le nombre d'éléments est supérieur à la capacité du HashSet multipliée par son taux de remplissage, le HashSet est élargi.

Outre les méthodes héritées de ses classes mères, HashSet définit les méthodes suivantes :

MéthodeDescription
boolean add(Object o)Ajouter l'élément spécifié à HashSet s'il n'est pas déjà présent.
boolean isEmpty()Retourner true si cet HashSet ne contient aucun élément.
Iterator iterator()Retourner un itérateur sur les éléments de cet HashSet.
boolean remove(Object o)Supprimer l'élément spécifié de cet HashSet s'il est présent.
int size()Retourner le nombre d'éléments.
void clear()Supprimer tous les éléments.
boolean contains(Object o)Retourner true si cet HashSet contient l'élément spécifié.
Exemple 1 :
                                    import java.util.HashSet;
                                    import java.util.Iterator;
                                    
                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            HashSet< String> pays = new HashSet< String>();
                                    
                                            // Ajouter des éléments dans HashSet en utilisant add()
                                            pays.add("Maroc");
                                            pays.add("Tunisie");
                                            pays.add("Algérie");
                                            pays.add("Espagne");
                                            pays.add("Malaisie");
                                            pays.add("Espagne");// ajouter un élément en double
                                    
                                            // Afficher HashSet
                                            System.out.println(pays);
                                    
                                            System.out.println("Est ce que la tunisie appartient aux pays :" + pays.contains("Tunisie"));
                                    
                                            // Suppression d'éléments de HashSet à l'aide de remove ()
                                            pays.remove("Espagne");
                                            System.out.println("Liste après avoir retiré l'espagne:" + pays);
                                    
                                            // Itérer sur HashSet
                                            System.out.println("Itérer sur pays :");
                                            Iterator< String> it = pays.iterator();
                                            while (it.hasNext())
                                                System.out.println(it.next());
                                        }
                                    }
                            
[Tunisie, Malaisie, Algérie, Maroc, Espagne]
Est ce que la tunisie appartient aux pays :true
Liste après avoir retiré l'espagne :[Tunisie, Malaisie, Algérie, Maroc]
Itérer sur pays :
Tunisie
Malaisie
Algérie
Maroc
Exemple 2 : HashSet à partir d'une autre collection
                                    import java.util.HashSet;
                                    import java.util.Iterator;
                                    import java.util.ArrayList;
                                    
                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            ArrayList< String> list = new ArrayList< String>();
                                            list.add("Maroc");
                                            list.add("Tunisie");
                                            list.add("Algérie");
                                    
                                            HashSet< String> set = new HashSet< String>(list);
                                            set.add("France");
                                            Iterator< String> i = set.iterator();
                                            while (i.hasNext()) {
                                                System.out.println(i.next());
                                            }
                                        }
                                    }
                            
Tunisie
Algérie
Maroc
France

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :