Ferrugem - Coleções

A biblioteca de coleção padrão do Rust fornece implementações eficientes das estruturas de dados de programação de propósito geral mais comuns. Este capítulo discute a implementação das coleções comumente usadas - Vector, HashMap e HashSet.

Vetor

Um vetor é uma matriz redimensionável. Ele armazena valores em blocos de memória contíguos. A estrutura predefinida Vec pode ser usada para criar vetores. Algumas características importantes de um vetor são -

  • Um vetor pode aumentar ou diminuir em tempo de execução.

  • Um vetor é uma coleção homogênea.

  • Um vetor armazena dados como sequência de elementos em uma ordem particular. Cada elemento em um vetor é atribuído a um número de índice exclusivo. O índice começa em 0 e vai até n-1, onde, n é o tamanho da coleção. Por exemplo, em uma coleção de 5 elementos, o primeiro elemento estará no índice 0 e o último elemento estará no índice 4.

  • Um vetor só acrescentará valores ao (ou próximo) ao final. Em outras palavras, um vetor pode ser usado para implementar uma pilha.

  • A memória para um vetor é alocada no heap.

Sintaxe - Criando um Vetor

let mut instance_name = Vec::new();

O método estático new () da estrutura Vec é usado para criar uma instância de vetor.

Como alternativa, um vetor também pode ser criado usando o vec! macro. A sintaxe é a seguinte -

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

A tabela a seguir lista algumas funções comumente usadas da estrutura Vec.

Sr. Não Método Assinatura e Descrição
1 Novo()

pub fn new()->Vect

Constrói um novo Vec vazio. O vetor não será alocado até que os elementos sejam colocados nele.
2 empurrar()

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

Acrescenta um elemento ao final de uma coleção.
3 retirar()

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

Remove e retorna o elemento no índice de posição dentro do vetor, deslocando todos os elementos após ele para a esquerda.
4 contém ()

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

Retorna verdadeiro se a fatia contiver um elemento com o valor fornecido.
5 len ()

pub fn len(&self) -> usize

Retorna o número de elementos no vetor, também conhecido como 'comprimento'.

Ilustração: Criando um Vetor - novo ()

Para criar um vetor, usamos o método estático 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);
}

O exemplo acima cria um Vector usando o método estático new () que é definido na estrutura Vec . A função push (val) anexa o valor passado como parâmetro à coleção. A função len () retorna o comprimento do vetor.

Resultado

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

Ilustração: Criando um Vetor - vec! Macro

O código a seguir cria um vetor usando o comando vec! macro. O tipo de dados do vetor é inferido como o primeiro valor atribuído a ele.

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

Resultado

[1, 2, 3]

Conforme mencionado anteriormente, um vetor só pode conter valores do mesmo tipo de dados. O seguinte snippet gerará um erro [E0308]: erro de tipos incompatíveis .

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

Ilustração: push ()

Acrescenta um elemento ao final de uma coleção.

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

Resultado

[20, 30, 40]

Ilustração: remove ()

Remove e retorna o elemento no índice de posição dentro do vetor, deslocando todos os elementos após ele para a esquerda.

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

Resultado

[10, 30]

Ilustração - contém ()

Retorna verdadeiro se a fatia contiver um elemento com o valor fornecido -

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

Resultado

found 10
[10, 20, 30]

Ilustração: len ()

Retorna o número de elementos no vetor, também conhecido como 'comprimento'.

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

Resultado

size of vector is :3

Acessando valores de um vetor

Elementos individuais em um vetor podem ser acessados ​​usando seus números de índice correspondentes. O exemplo a seguir cria um anúncio vetorial e imprime o valor do primeiro elemento.

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

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

Os valores em um vetor também podem ser buscados usando referência à coleção.

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

Resultado

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

HashMap

Um mapa é uma coleção de pares de valores-chave (chamados de entradas). Duas entradas em um mapa não podem ter a mesma chave. Resumindo, um mapa é uma tabela de consulta. Um HashMap armazena as chaves e os valores em uma tabela hash. As entradas são armazenadas em uma ordem arbitrária. A chave é usada para pesquisar valores no HashMap. A estrutura HashMap é definida nostd::collectionsmódulo. Este módulo deve ser importado explicitamente para acessar a estrutura HashMap.

Sintaxe: Criando um HashMap

let mut instance_name = HashMap::new();

O método estático new () da estrutura HashMap é usado para criar um objeto HashMap. Este método cria um HashMap vazio.

As funções comumente usadas de HashMap são discutidas abaixo -

Sr. Não Método Assinatura e Descrição
1 inserir()

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

Insere um par chave / valor; se nenhuma chave, então Nenhum é retornado. Após a atualização, o valor antigo é retornado.
2 len ()

pub fn len(&self) -> usize

Retorna o número de elementos no mapa.
3 pegue()

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

Retorna uma referência ao valor correspondente à chave.
4 iter ()

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

Um iterador que visita todos os pares de valores-chave em ordem arbitrária. O tipo de elemento iterador é (& 'a K, &' a V).
5 contém_chave

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

Retorna verdadeiro se o mapa contém um valor para a chave especificada.
6 retirar()

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

Remove uma chave do mapa, retornando a chave e o valor armazenados se a chave estava anteriormente no mapa.

Ilustração: inserir ()

Insere um par chave / valor no HashMap.

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

O programa acima cria um HashMap e o inicializa com 2 pares de valores-chave.

Resultado

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

Ilustração: len ()

Retorna o número de elementos no mapa

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

O exemplo acima cria um HashMap e imprime o número total de elementos nele.

Resultado

size of map is 2

Ilustração - get ()

Retorna uma referência ao valor correspondente à chave. O exemplo a seguir recupera o valor da chave KL no 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");
      }
   }
}

Resultado

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

Ilustração - iter ()

Retorna um iterador contendo referência a todos os pares de valores-chave em uma ordem arbitrária.

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

Resultado

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

Ilustração: contains_key ()

Retorna verdadeiro se o mapa contém um valor para a chave especificada.

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

Resultado

found key

Ilustração: remove ()

Remove uma chave do mapa.

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

Resultado

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

HashSet

HashSet é um conjunto de valores exclusivos do tipo T. Adicionar e remover valores é rápido e é rápido perguntar se um determinado valor está no conjunto ou não. A estrutura HashSet é definida no módulo std :: Collections. Este módulo deve ser importado explicitamente para acessar a estrutura HashSet.

Sintaxe: Criando um HashSet

let mut hash_set_name = HashSet::new();

O método estático, novo , da estrutura HashSet é usado para criar um HashSet. Este método cria um HashSet vazio.

A tabela a seguir lista alguns dos métodos comumente usados ​​da estrutura HashSet.

Sr. Não Método Assinatura e Descrição
1 inserir()

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

Adiciona um valor ao conjunto. Se o conjunto não tiver este valor presente, true é retornado, caso contrário, false.
2 len ()

pub fn len(&self) -> usize

Retorna o número de elementos do conjunto.
3 pegue()

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

Retorna uma referência ao valor no conjunto, se houver alguma que seja igual ao valor fornecido.
4 iter ()

pub fn iter(&self) -> Iter

Retorna um iterador visitando todos os elementos em ordem arbitrária. O tipo de elemento iterador é & 'a T.
5 contém_chave

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

Retorna verdadeiro se o conjunto contiver um valor.
6 retirar()

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

Remove um valor do conjunto. Retorna verdadeiro se o valor estava presente no conjunto.

Ilustração - inserir ()

Adiciona um valor ao conjunto. Um HashSet não adiciona valores duplicados à coleção.

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

Resultado

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

Ilustração: len ()

Retorna o número de elementos do conjunto.

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

Resultado

size of the set is 3

Ilustração - iter ()

Recupera um iterador visitando todos os elementos em ordem arbitrária.

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

Resultado

TutorialsPoint
Mohtashim
Kannan

Ilustração: get ()

Retorna uma referência ao valor no conjunto, se houver, que é igual ao valor fornecido.

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

Resultado

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

Ilustração - contém ()

Retorna verdadeiro se o conjunto contiver um valor.

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

Resultado

found name

Ilustração: remove ()

Remove um valor do conjunto.

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

Resultado

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