Utiliser HashSet
Suivez des valeurs uniques.
Utiliser HashSet est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu’est-ce qu’un HashSet ?
Un HashSet stocke une collection de valeurs uniques. Il n’y a ni doublons ni clés, seulement des membres.
Il est idéal pour répondre rapidement à une question : « Ai-je déjà vu cette valeur ? »
Créer un ensemble
Comme HashMap, HashSet se trouve dans std::collections et nécessite un import use.
Créez-en un vide avec HashSet::new() et déclarez-le avec mut pour pouvoir y ajouter des éléments.
use std::collections::HashSet;
fn main() {
let mut s: HashSet<i32> = HashSet::new();
s.insert(1);
s.insert(2);
println!("size: {}", s.len());
}Insertion et doublons
La méthode insert renvoie un bool : true si la valeur était nouvelle, false si elle était déjà présente.
L’insertion d’un doublon ne fait rien : l’unicité de l’ensemble est donc préservée automatiquement.
use std::collections::HashSet;
fn main() {
let mut s = HashSet::new();
println!("{}", s.insert(5));
println!("{}", s.insert(5));
println!("len = {}", s.len());
}Tester l’appartenance
Utilisez contains pour vérifier qu’une valeur appartient à l’ensemble. La méthode renvoie un bool.
C’est la raison la plus courante d’utiliser un ensemble : les recherches sont rapides et claires.
use std::collections::HashSet;
fn main() {
let mut s = HashSet::new();
s.insert("red");
s.insert("blue");
println!("has red? {}", s.contains("red"));
println!("has green? {}", s.contains("green"));
}Supprimer des membres
La méthode remove reçoit une valeur et renvoie true si celle-ci était présente et a été supprimée.
La suppression d’un élément absent renvoie simplement false.
use std::collections::HashSet;
fn main() {
let mut s = HashSet::new();
s.insert(7);
println!("{}", s.remove(&7));
println!("{}", s.remove(&7));
}Construire à partir d’un itérateur
Vous pouvez recueillir directement dans un HashSet les valeurs de n’importe quel itérateur.
C’est un moyen rapide d’éliminer les doublons : fournissez une liste contenant des répétitions et l’ensemble ne conserve chaque valeur qu’une seule fois.
use std::collections::HashSet;
fn main() {
let nums = [1, 2, 2, 3, 3, 3];
let unique: HashSet<i32> = nums.iter().copied().collect();
println!("distinct: {}", unique.len());
}Parcourir un ensemble
Parcourez un ensemble avec une boucle for pour visiter chacun de ses membres.
Comme pour HashMap, l’ordre de parcours n’est pas garanti et peut différer à chaque exécution.
use std::collections::HashSet;
fn main() {
let s: HashSet<i32> = [10, 20, 30].into_iter().collect();
let mut total = 0;
for v in &s {
total += v;
}
println!("sum = {}", total);
}Union
La méthode union fournit chaque valeur présente dans l’un ou l’autre ensemble.
Elle renvoie un itérateur : recueillez donc son contenu dans un nouvel ensemble ou parcourez-le.
use std::collections::HashSet;
fn main() {
let a: HashSet<i32> = [1, 2, 3].into_iter().collect();
let b: HashSet<i32> = [3, 4].into_iter().collect();
let u: HashSet<i32> = a.union(&b).copied().collect();
println!("union size: {}", u.len());
}Intersection
La méthode intersection produit les valeurs présentes dans les deux ensembles.
Elle est idéale pour trouver les éléments communs, comme des balises partagées ou des amis communs.
use std::collections::HashSet;
fn main() {
let a: HashSet<i32> = [1, 2, 3].into_iter().collect();
let b: HashSet<i32> = [2, 3, 4].into_iter().collect();
let common: Vec<i32> = a.intersection(&b).copied().collect();
println!("common count: {}", common.len());
}Différence
La méthode difference produit les valeurs du premier ensemble qui ne se trouvent pas dans le second.
Inversez l’ordre pour obtenir la différence opposée. Il existe également symmetric_difference pour les éléments présents dans un seul des deux ensembles.
use std::collections::HashSet;
fn main() {
let a: HashSet<i32> = [1, 2, 3].into_iter().collect();
let b: HashSet<i32> = [2].into_iter().collect();
let only_a: Vec<i32> = a.difference(&b).copied().collect();
println!("only in a: {}", only_a.len());
}Sous-ensemble et disjonction
Utilisez is_subset pour vérifier que chaque membre d’un ensemble se trouve dans un autre.
Utilisez is_disjoint pour vérifier que deux ensembles ne partagent absolument aucune valeur. Les deux méthodes renvoient un simple bool.
use std::collections::HashSet;
fn main() {
let a: HashSet<i32> = [1, 2].into_iter().collect();
let b: HashSet<i32> = [1, 2, 3].into_iter().collect();
println!("a subset of b? {}", a.is_subset(&b));
}Vérification rapide
Vous insérez deux fois la même valeur dans un HashSet.
Récapitulatif
Un HashSet contient des valeurs uniques et permet d’effectuer rapidement des vérifications avec contains.
Vous avez inséré, supprimé, éliminé les doublons avec collect et combiné des ensembles avec union, intersection et difference.
Questions Fréquemment Posées
La leçon « Utiliser HashSet » est-elle gratuite ?
Oui — le texte complet de « Utiliser HashSet » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Utiliser HashSet » ?
Suivez des valeurs uniques. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Utiliser HashSet » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.