HashMap en

À propos de HashMap

Un HashMap est un conteneur qui peut être utilisé pour stocker des paires clé-valeur. Dans d'autres langages de programmation, cette structure de données est parfois appelée tableau associatif ou table de hachage. Le HashMap contient un ensemble de clés, chacune étant associée à une valeur particulière. L'utilisateur peut récupérer une valeur stockée en passant la clé appropriée. Les utilisateurs peuvent également insérer et supprimer des clés et les valeurs associées.

HashMap est une collection générique (comme la plupart des collections de la bibliothèque standard) et prend donc en charge une grande variété de types en tant que clés, y compris des structures et des tuples définis par l'utilisateur. Ses valeurs peuvent être de n'importe quel type.

Créer un HashMap

Un HashMap est créé à l'aide de la fonction HashMap::new(). L'extrait de code ci-dessous crée un HashMap associant des noms d'équipes à des scores.

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

Accède aux valeurs d'un HashMap

Si l'on sait qu'une valeur existe dans un HashMap, il est alors approprié d'utiliser l'opérateur d'indexation ([]). Pour récupérer le score de l'équipe bleue, par exemple, on peut utiliser scores["Blue"]. Cependant, si la paire clé-valeur appropriée n'existe pas dans le HashMap, cette opération paniquera.

Outre l'opérateur d'indexation, il existe deux autres façons d'accéder aux valeurs stockées dans un HashMap. La première consiste à utiliser la fonction membre get :

if let Some(blue_score) = scores.get("Blue") {
    println!("Blue scored: {blue_score} \n");
}

get accède à la valeur stockée pour la clé demandée. Il renvoie None si la clé fournie n'existe pas dans le HashMap, et Some(value) si la clé existe. Pour plus d'informations sur les Options en Rust, consulte le concept Options.

L'autre façon d'accéder aux valeurs stockées dans un HashMap est d'utiliser la méthode entry. La méthode entry (ou l'API entry) renvoie une référence à l'entrée de la paire clé-valeur dans le HashMap. L'entrée représente l'état de cette clé dans le HashMap. Si la clé n'existe pas, alors il n'y a pas de valeur dans l'entrée (et cela permet d'en insérer une).

let mut vote_counter: HashMap<_, usize> = HashMap::new();
let votes = ["Blue", "Red", "Red", "Blue", "Red", "Blue", "Blue"];
for vote in votes {
    let count = vote_counter.entry(vote).or_default();
    *count += 1;
}

println!("{vote_counter:#?}");

Cette API rend certains modèles d'accès courants très pratiques ; elle dispose d'un concept entier (Entry API) qui lui est consacré.

Efficacité

Les HashMap sont relativement rapides et ont une complexité amortie en temps constant (O(1)) pour toutes les opérations impliquant une seule clé.

Contraintes de traits

Un HashMap est une structure de données générique, ce qui signifie qu'il prend en charge des types arbitraires comme clés et valeurs, avec une seule contrainte : pour qu'un type soit utilisé comme type de clé, il doit avoir une implémentation de deux traits : Eq et Hash. Il n'y a aucune contrainte de trait sur le type de valeur.