Rouille - Collections

La bibliothèque de collection standard de Rust fournit des implémentations efficaces des structures de données de programmation générales les plus courantes. Ce chapitre traite de l'implémentation des collections couramment utilisées - Vector, HashMap et HashSet.

Vecteur

Un vecteur est un tableau redimensionnable. Il stocke les valeurs dans des blocs de mémoire contigus. La structure prédéfinie Vec peut être utilisée pour créer des vecteurs. Certaines caractéristiques importantes d'un vecteur sont:

  • Un vecteur peut grossir ou diminuer au moment de l'exécution.

  • Un vecteur est une collection homogène.

  • Un vecteur stocke les données sous forme de séquence d'éléments dans un ordre particulier. Chaque élément d'un vecteur reçoit un numéro d'index unique. L'index commence à 0 et va jusqu'à n-1 où, n est la taille de la collection. Par exemple, dans une collection de 5 éléments, le premier élément sera à l'index 0 et le dernier élément sera à l'index 4.

  • Un vecteur ajoutera des valeurs uniquement à (ou près de) la fin. En d'autres termes, un vecteur peut être utilisé pour implémenter une pile.

  • La mémoire d'un vecteur est allouée dans le tas.

Syntaxe - Création d'un vecteur

let mut instance_name = Vec::new();

La méthode statique new () de la structure Vec est utilisée pour créer une instance vectorielle.

Alternativement, un vecteur peut également être créé en utilisant le vec! macro. La syntaxe est la suivante -

let vector_name = vec![val1,val2,val3]

Le tableau suivant répertorie certaines fonctions couramment utilisées de la structure Vec.

Sr.Non Méthode Signature et description
1 Nouveau()

pub fn new()->Vect

Construit un nouveau Vec vide. Le vecteur ne sera pas alloué tant que les éléments n'y seront pas poussés.
2 pousser()

pub fn push(&mut self, value: T)

Ajoute un élément à l'arrière d'une collection.
3 retirer()

pub fn remove(&mut self, index: usize) -> T

Supprime et renvoie l'élément à l'index de position dans le vecteur, en décalant tous les éléments après celui-ci vers la gauche.
4 contient ()

pub fn contains(&self, x: &T) -> bool

Renvoie true si la tranche contient un élément avec la valeur donnée.
5 len ()

pub fn len(&self) -> usize

Renvoie le nombre d'éléments dans le vecteur, également appelé sa «longueur».

Illustration: Création d'un vecteur - nouveau ()

Pour créer un vecteur, nous utilisons la méthode statique new -

fn main() {
   let mut v = Vec::new();
   v.push(20);
   v.push(30);
   v.push(40);

   println!("size of vector is :{}",v.len());
   println!("{:?}",v);
}

L'exemple ci-dessus crée un vecteur en utilisant la méthode statique new () qui est définie dans la structure Vec . La fonction push (val) ajoute la valeur passée en paramètre à la collection. La fonction len () renvoie la longueur du vecteur.

Production

size of vector is :3
[20, 30, 40]

Illustration: création d'un vecteur - vec! Macro

Le code suivant crée un vecteur à l'aide de vec! macro. Le type de données du vecteur est déduit de la première valeur qui lui est affectée.

fn main() {
   let v = vec![1,2,3];
   println!("{:?}",v);
}

Production

[1, 2, 3]

Comme mentionné précédemment, un vecteur ne peut contenir que des valeurs du même type de données. L'extrait de code suivant générera une erreur [E0308]: erreur de types incompatibles .

fn main() {
   let v = vec![1,2,3,"hello"];
   println!("{:?}",v);
}

Illustration: pousser ()

Ajoute un élément à la fin d'une collection.

fn main() {
   let mut v = Vec::new();
   v.push(20);
   v.push(30);
   v.push(40);
   
   println!("{:?}",v);
}

Production

[20, 30, 40]

Illustration: remove ()

Supprime et renvoie l'élément à l'index de position dans le vecteur, en décalant tous les éléments après celui-ci vers la gauche.

fn main() {
   let mut v = vec![10,20,30];
   v.remove(1);
   println!("{:?}",v);
}

Production

[10, 30]

Illustration - contient ()

Renvoie true si la tranche contient un élément avec la valeur donnée -

fn main() {
   let v = vec![10,20,30];
   if v.contains(&10) {
      println!("found 10");
   }
   println!("{:?}",v);
}

Production

found 10
[10, 20, 30]

Illustration: len ()

Renvoie le nombre d'éléments dans le vecteur, également appelé sa «longueur».

fn main() {
   let v = vec![1,2,3];
   println!("size of vector is :{}",v.len());
}

Production

size of vector is :3

Accéder aux valeurs d'un vecteur

Les éléments individuels d'un vecteur sont accessibles en utilisant leurs numéros d'index correspondants. L'exemple suivant crée une annonce vectorielle imprime la valeur du premier élément.

fn main() {
   let mut v = Vec::new();
   v.push(20);
   v.push(30);

   println!("{:?}",v[0]);
}
Output: `20`

Les valeurs d'un vecteur peuvent également être récupérées à l'aide d'une référence à la collection.

fn main() {
   let mut v = Vec::new();
   v.push(20);
   v.push(30);
   v.push(40);
   v.push(500);

   for i in &v {
      println!("{}",i);
   }
   println!("{:?}",v);
}

Production

20
30
40
500
[20, 30, 40, 500]

HashMap

Une carte est une collection de paires clé-valeur (appelées entrées). Aucune entrée dans une carte ne peut avoir la même clé. En bref, une carte est une table de consultation. Un HashMap stocke les clés et les valeurs dans une table de hachage. Les entrées sont stockées dans un ordre arbitraire. La clé est utilisée pour rechercher des valeurs dans le HashMap. La structure HashMap est définie dans lestd::collectionsmodule. Ce module doit être importé explicitement pour accéder à la structure HashMap.

Syntaxe: Création d'un HashMap

let mut instance_name = HashMap::new();

La méthode statique new () de la structure HashMap est utilisée pour créer un objet HashMap. Cette méthode crée un HashMap vide.

Les fonctions couramment utilisées de HashMap sont discutées ci-dessous -

Sr.Non Méthode Signature et description
1 insérer()

pub fn insert(&mut self, k: K, v: V) -> Option

Insère une paire clé / valeur, si aucune clé, aucune n'est renvoyée. Après la mise à jour, l'ancienne valeur est renvoyée.
2 len ()

pub fn len(&self) -> usize

Renvoie le nombre d'éléments de la carte.
3 avoir()

pub fn get<Q: ?Sized>(&lself, k: &Q) -> Option<&V> where K:Borrow Q:Hash+ Eq

Renvoie une référence à la valeur correspondant à la clé.
4 iter ()

pub fn iter(&self) -> Iter<K, V>

Un itérateur visitant toutes les paires clé-valeur dans un ordre arbitraire. Le type d'élément de l'itérateur est (& 'a K, &' a V).
5 contains_key

pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool

Renvoie true si la carte contient une valeur pour la clé spécifiée.
6 retirer()

pub fn remove_entry<Q: ?Sized>(&mut self, k: &Q) -> Option<(K, V)>

Supprime une clé de la carte, renvoyant la clé et la valeur stockées si la clé était auparavant dans la carte.

Illustration: insérer ()

Insère une paire clé / valeur dans le HashMap.

use std::collections::HashMap;
fn main(){
   let mut stateCodes = HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Maharashtra");
   println!("{:?}",stateCodes);
}

Le programme ci-dessus crée un HashMap et l'initialise avec 2 paires clé-valeur.

Production

{"KL": "Kerala", "MH": "Maharashtra"}

Illustration: len ()

Renvoie le nombre d'éléments de la carte

use std::collections::HashMap;
fn main() {
   let mut stateCodes = HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Maharashtra");
   println!("size of map is {}",stateCodes.len());
}

L'exemple ci-dessus crée un HashMap et imprime le nombre total d'éléments qu'il contient.

Production

size of map is 2

Illustration - get ()

Renvoie une référence à la valeur correspondant à la clé. L'exemple suivant récupère la valeur de la clé KL dans le HashMap.

use std::collections::HashMap;
fn main() {
   let mut stateCodes = HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Maharashtra");
   println!("size of map is {}",stateCodes.len());
   println!("{:?}",stateCodes);

   match stateCodes.get(&"KL") {
      Some(value)=> {
         println!("Value for key KL is {}",value);
      }
      None => {
         println!("nothing found");
      }
   }
}

Production

size of map is 2
{"KL": "Kerala", "MH": "Maharashtra"}
Value for key KL is Kerala

Illustration - Iter ()

Renvoie un itérateur contenant une référence à toutes les paires clé-valeur dans un ordre arbitraire.

use std::collections::HashMap;
fn main() {
   let mut stateCodes = HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Maharashtra");

   for (key, val) in stateCodes.iter() {
      println!("key: {} val: {}", key, val);
   }
}

Production

key: MH val: Maharashtra
key: KL val: Kerala

Illustration: contains_key ()

Renvoie true si la carte contient une valeur pour la clé spécifiée.

use std::collections::HashMap;
fn main() {
   let mut stateCodes = HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Maharashtra");
   stateCodes.insert("GJ","Gujarat");

   if stateCodes.contains_key(&"GJ") {
      println!("found key");
   }
}

Production

found key

Illustration: remove ()

Supprime une clé de la carte.

use std::collections::HashMap;
fn main() {
   let mut stateCodes = HashMap::new();
   stateCodes.insert("KL","Kerala");
   stateCodes.insert("MH","Maharashtra");
   stateCodes.insert("GJ","Gujarat");

   println!("length of the hashmap {}",stateCodes.len());
   stateCodes.remove(&"GJ");
   println!("length of the hashmap after remove() {}",stateCodes.len());
}

Production

length of the hashmap 3
length of the hashmap after remove() 2

HashSet

HashSet est un ensemble de valeurs uniques de type T. L'ajout et la suppression de valeurs est rapide, et il est rapide de demander si une valeur donnée est dans l'ensemble ou non. La structure HashSet est définie dans le module std :: collections. Ce module doit être importé explicitement pour accéder à la structure HashSet.

Syntaxe: Création d'un HashSet

let mut hash_set_name = HashSet::new();

La méthode statique, nouvelle , de la structure HashSet est utilisée pour créer un HashSet. Cette méthode crée un HashSet vide.

Le tableau suivant répertorie certaines des méthodes couramment utilisées de la structure HashSet.

Sr.Non Méthode Signature et description
1 insérer()

pub fn insert(&mut self, value: T) -> bool

Ajoute une valeur à l'ensemble. Si l'ensemble n'avait pas cette valeur présente, true est renvoyé, sinon false.
2 len ()

pub fn len(&self) -> usize

Renvoie le nombre d'éléments de l'ensemble.
3 avoir()

pub fn get<Q:?Sized>(&self, value: &Q) -> Option<&T> where T: Borrow,Q: Hash + Eq,

Renvoie une référence à la valeur de l'ensemble, le cas échéant, égale à la valeur donnée.
4 iter ()

pub fn iter(&self) -> Iter

Renvoie un itérateur visitant tous les éléments dans un ordre arbitraire. Le type d'élément itérateur est & 'a T.
5 contains_key

pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool

Renvoie true si l'ensemble contient une valeur.
6 retirer()

pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool

Supprime une valeur de l'ensemble. Renvoie true si la valeur était présente dans l'ensemble.

Illustration - insérer ()

Ajoute une valeur à l'ensemble. Un HashSet n'ajoute pas de valeurs en double à la collection.

use std::collections::HashSet;
fn main() {
   let mut names = HashSet::new();

   names.insert("Mohtashim");
   names.insert("Kannan");
   names.insert("TutorialsPoint");
   names.insert("Mohtashim");//duplicates not added

   println!("{:?}",names);
}

Production

{"TutorialsPoint", "Kannan", "Mohtashim"}

Illustration: len ()

Renvoie le nombre d'éléments de l'ensemble.

use std::collections::HashSet;
fn main() {
   let mut names = HashSet::new();
   names.insert("Mohtashim");
   names.insert("Kannan");
   names.insert("TutorialsPoint");
   println!("size of the set is {}",names.len());
}

Production

size of the set is 3

Illustration - Iter ()

Récupère un itérateur visitant tous les éléments dans un ordre arbitraire.

use std::collections::HashSet;
fn main() {
   let mut names = HashSet::new();
   names.insert("Mohtashim");
   names.insert("Kannan");
   names.insert("TutorialsPoint");
   names.insert("Mohtashim");

   for name in names.iter() {
      println!("{}",name);
   }
}

Production

TutorialsPoint
Mohtashim
Kannan

Illustration: get ()

Renvoie une référence à la valeur de l'ensemble, le cas échéant, qui est égale à la valeur donnée.

use std::collections::HashSet;
fn main() {
   let mut names = HashSet::new();
   names.insert("Mohtashim");
   names.insert("Kannan");
   names.insert("TutorialsPoint");
   names.insert("Mohtashim");

   match names.get(&"Mohtashim"){
      Some(value)=>{
         println!("found {}",value);
      }
      None =>{
         println!("not found");
      }
   }
   println!("{:?}",names);
}

Production

found Mohtashim
{"Kannan", "Mohtashim", "TutorialsPoint"}

Illustration - contient ()

Renvoie true si l'ensemble contient une valeur.

use std::collections::HashSet;

fn main() {
   let mut names = HashSet::new();
   names.insert("Mohtashim");
   names.insert("Kannan");
   names.insert("TutorialsPoint");

   if names.contains(&"Kannan") {
      println!("found name");
   }  
}

Production

found name

Illustration: remove ()

Supprime une valeur de l'ensemble.

use std::collections::HashSet;

fn main() {
   let mut names = HashSet::new();
   names.insert("Mohtashim");
   names.insert("Kannan");
   names.insert("TutorialsPoint");
   println!("length of the Hashset: {}",names.len());
   names.remove(&"Kannan");
   println!("length of the Hashset after remove() : {}",names.len());
}

Production

length of the Hashset: 3
length of the Hashset after remove() : 2