Rust - Kolekcje

Biblioteka kolekcji standardowych Rusta zapewnia wydajne implementacje najpopularniejszych struktur danych programowania ogólnego przeznaczenia. W tym rozdziale omówiono implementację najczęściej używanych kolekcji - Vector, HashMap i HashSet.

Wektor

Vector to tablica o zmiennym rozmiarze. Przechowuje wartości w ciągłych blokach pamięci. Do tworzenia wektorów można wykorzystać predefiniowaną strukturę Vec. Niektóre ważne cechy Vector to -

  • Wektor może rosnąć lub zmniejszać się w czasie wykonywania.

  • Wektor to zbiór jednorodny.

  • Vector przechowuje dane jako sekwencje elementów w określonej kolejności. Każdy element wektora ma przypisany unikalny numer indeksu. Indeks zaczyna się od 0 i dochodzi do n-1, gdzie n jest rozmiarem kolekcji. Na przykład w kolekcji 5 elementów pierwszy element będzie miał indeks 0, a ostatni element będzie miał indeks 4.

  • Wektor doda wartości tylko na końcu (lub blisko). Innymi słowy, do implementacji stosu można użyć wektora.

  • Pamięć dla wektora jest przydzielana w stercie.

Składnia - tworzenie wektora

let mut instance_name = Vec::new();

Metoda statyczna nowy () z Vec konstrukcji jest stosowany do tworzenia wystąpienie wektorowych.

Alternatywnie wektor można również utworzyć za pomocą polecenia vec! makro. Składnia jest taka, jak podano poniżej -

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

W poniższej tabeli wymieniono niektóre często używane funkcje struktury Vec.

Sr.No metoda Podpis i opis
1 Nowy()

pub fn new()->Vect

Konstruuje nowy, pusty Vec. Wektor nie zostanie przydzielony, dopóki elementy nie zostaną do niego przesunięte.
2 Pchać()

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

Dołącza element z tyłu kolekcji.
3 usunąć()

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

Usuwa i zwraca element z indeksem pozycji w wektorze, przesuwając wszystkie elementy po nim w lewo.
4 zawiera ()

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

Zwraca wartość true, jeśli wycinek zawiera element o podanej wartości.
5 len ()

pub fn len(&self) -> usize

Zwraca liczbę elementów w wektorze, nazywaną również jego „długością”.

Ilustracja: Tworzenie wektora - new ()

Do stworzenia wektora używamy statycznej metody 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);
}

Powyższy przykład tworzy Vector przy użyciu statycznej metody new () zdefiniowanej w strukturze Vec . Funkcja push (val) dołącza wartość przekazaną jako parametr do kolekcji. Funkcja len () zwraca długość wektora.

Wynik

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

Ilustracja: Tworzenie wektora - vec! Makro

Poniższy kod tworzy wektor przy użyciu polecenia vec! makro. Typ danych wektora jest wywnioskowany jako pierwsza przypisana mu wartość.

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

Wynik

[1, 2, 3]

Jak wspomniano wcześniej, wektor może zawierać tylko wartości tego samego typu danych. Poniższy fragment kodu zgłosi błąd [E0308]: błąd niezgodnych typów .

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

Ilustracja: push ()

Dołącza element na końcu kolekcji.

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

Wynik

[20, 30, 40]

Ilustracja: usuń ()

Usuwa i zwraca element z indeksem pozycji w wektorze, przesuwając wszystkie elementy po nim w lewo.

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

Wynik

[10, 30]

Ilustracja - zawiera ()

Zwraca wartość true, jeśli wycinek zawiera element o podanej wartości -

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

Wynik

found 10
[10, 20, 30]

Ilustracja: len ()

Zwraca liczbę elementów w wektorze, nazywaną również jego „długością”.

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

Wynik

size of vector is :3

Dostęp do wartości z obiektu Vector

Dostęp do poszczególnych elementów w wektorze można uzyskać za pomocą odpowiednich numerów indeksu. Poniższy przykład tworzy reklamę wektorową, drukuje wartość pierwszego elementu.

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

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

Wartości w wektorze można również pobrać za pomocą odniesienia do kolekcji.

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);
}

Wynik

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

HashMap

Mapa to zbiór par klucz-wartość (zwanych wpisami). Żadne dwa wpisy na mapie nie mogą mieć tego samego klucza. Krótko mówiąc, mapa to tablica przeglądowa. HashMap przechowuje klucze i wartości w tabeli skrótów. Wpisy są przechowywane w dowolnej kolejności. Klucz służy do wyszukiwania wartości w HashMap. Struktura HashMap jest zdefiniowana wstd::collectionsmoduł. Ten moduł należy jawnie zaimportować, aby uzyskać dostęp do struktury HashMap.

Składnia: tworzenie HashMap

let mut instance_name = HashMap::new();

Metoda statyczna nowy () z hashmap strukturze służy do utworzenia obiektu hashmap. Ta metoda tworzy pusty HashMap.

Często używane funkcje HashMap zostały omówione poniżej -

Sr.No metoda Podpis i opis
1 wstawić()

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

Wstawia parę klucz / wartość, jeśli nie ma klucza, zwracany jest None. Po aktualizacji zwracana jest stara wartość.
2 len ()

pub fn len(&self) -> usize

Zwraca liczbę elementów na mapie.
3 dostać()

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

Zwraca odwołanie do wartości odpowiadającej kluczowi.
4 iter ()

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

Iterator odwiedzający wszystkie pary klucz-wartość w dowolnej kolejności. Typ elementu iteratora to (& 'a K, &' a V).
5 zawiera_klucz

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

Zwraca wartość true, jeśli mapa zawiera wartość dla określonego klucza.
6 usunąć()

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

Usuwa klucz z mapy, zwracając przechowywany klucz i wartość, jeśli klucz był wcześniej w mapie.

Ilustracja: wstaw ()

Wstawia parę klucz / wartość do HashMap.

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

Powyższy program tworzy HashMap i inicjalizuje go za pomocą 2 par klucz-wartość.

Wynik

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

Ilustracja: len ()

Zwraca liczbę elementów na mapie

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());
}

Powyższy przykład tworzy HashMap i wyświetla całkowitą liczbę zawartych w niej elementów.

Wynik

size of map is 2

Ilustracja - get ()

Zwraca odwołanie do wartości odpowiadającej kluczowi. Poniższy przykład pobiera wartość klucza KL w 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");
      }
   }
}

Wynik

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

Ilustracja - iter ()

Zwraca iterator zawierający odniesienie do wszystkich par klucz-wartość w dowolnej kolejności.

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);
   }
}

Wynik

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

Ilustracja: zawiera_klucz ()

Zwraca wartość true, jeśli mapa zawiera wartość dla określonego klucza.

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");
   }
}

Wynik

found key

Ilustracja: usuń ()

Usuwa klucz z mapy.

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());
}

Wynik

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

HashSet

HashSet to zestaw unikalnych wartości typu T. Dodawanie i usuwanie wartości jest szybkie i szybko można zapytać, czy dana wartość jest w zestawie, czy nie. Struktura HashSet jest zdefiniowana w module std :: collections. Ten moduł należy jawnie zaimportować, aby uzyskać dostęp do struktury HashSet.

Składnia: tworzenie HashSet

let mut hash_set_name = HashSet::new();

Metoda statyczna nowej struktury HashSet służy do tworzenia HashSet. Ta metoda tworzy pusty zestaw HashSet.

W poniższej tabeli wymieniono niektóre z powszechnie używanych metod struktury HashSet.

Sr.No metoda Podpis i opis
1 wstawić()

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

Dodaje wartość do zestawu. Jeśli zestaw nie miał tej wartości, zwracana jest prawda, w przeciwnym razie fałsz.
2 len ()

pub fn len(&self) -> usize

Zwraca liczbę elementów w zestawie.
3 dostać()

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

Zwraca odniesienie do wartości w zestawie, jeśli takie jest, równe podanej wartości.
4 iter ()

pub fn iter(&self) -> Iter

Zwraca iterator odwiedzający wszystkie elementy w dowolnej kolejności. Typ elementu iteratora to & 'a T.
5 zawiera_klucz

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

Zwraca wartość true, jeśli zestaw zawiera wartość.
6 usunąć()

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

Usuwa wartość z zestawu. Zwraca wartość true, jeśli wartość była obecna w zestawie.

Ilustracja - wstaw ()

Dodaje wartość do zestawu. HashSet nie dodaje zduplikowanych wartości do kolekcji.

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);
}

Wynik

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

Ilustracja: len ()

Zwraca liczbę elementów w zestawie.

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());
}

Wynik

size of the set is 3

Ilustracja - iter ()

Ponownie uruchamia iterator odwiedzający wszystkie elementy w dowolnej kolejności.

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);
   }
}

Wynik

TutorialsPoint
Mohtashim
Kannan

Ilustracja: get ()

Zwraca odniesienie do wartości w zestawie, jeśli istnieje, która jest równa podanej wartości.

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);
}

Wynik

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

Ilustracja - zawiera ()

Zwraca wartość true, jeśli zestaw zawiera wartość.

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");
   }  
}

Wynik

found name

Ilustracja: usuń ()

Usuwa wartość z zestawu.

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());
}

Wynik

length of the Hashset: 3
length of the Hashset after remove() : 2
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved