Lição 14 de 18 · 30 min
Coleções
Guarde muitos valores com Vec, String e HashMap, entenda por que acentos mudam o jeito de ler texto e conte palavras com entry.
Ao terminar, você vai saber:
- Criar, ler e percorrer um Vec com segurança
- Montar textos com push_str e format! e percorrer letras com chars
- Entender por que uma String não é indexada por posição
- Guardar e buscar pares de chave e valor num HashMap
- Contar ocorrências com entry e or_insert
Arrays e tuplas têm tamanho fixo, decidido na hora de compilar. Na vida real, quase nada é assim: a lista de compras cresce, o carrinho esvazia, o cadastro ganha clientes novos. Para isso existem as coleções, que guardam dados no heap e podem mudar de tamanho enquanto o programa roda.
As três que você mais vai usar: Vec, String e HashMap.
Vec: uma lista que cresce
fn main() {
// Vec vazio: o tipo precisa aparecer em algum lugar
let mut compras: Vec<String> = Vec::new();
compras.push(String::from("arroz"));
compras.push(String::from("feijão"));
compras.push(String::from("farinha"));
// Com a macro vec! já nasce com itens
let mut notas = vec![7.0, 8.5, 6.0];
notas.push(9.5);
println!("{} itens na lista, {} notas", compras.len(), notas.len());
// Tira o último item
if let Some(ultimo) = compras.pop() {
println!("Removi: {ultimo}");
}
}
Lembre: para dar push, a variável precisa ser mut. Todos os itens de um Vec são do mesmo tipo.
Índice ou get?
Há dois jeitos de ler um item. Com colchetes, notas[0], ou com o método get.
fn main() {
let notas = vec![7.0, 8.5, 6.0];
let primeira = notas[0]; // direto
println!("Primeira nota: {primeira}");
// get devolve Option: Some se existe, None se não
match notas.get(10) {
Some(nota) => println!("Décima primeira nota: {nota}"),
None => println!("Não existe a posição 10"),
}
}
A diferença aparece quando a posição não existe. notas[10] faz o programa parar com panic!:
thread 'main' panicked at src/main.rs:3:18:
index out of bounds: the len is 3 but the index is 10
Já notas.get(10) devolve None, e você decide o que fazer. Regra prática: se a posição vem de fora (do usuário, de um arquivo), use get. Se você tem certeza de que existe, o colchete é mais curto.
Percorrendo
fn main() {
let mut precos = vec![4.50, 12.00, 3.25];
// Só leitura: empresta com &
for preco in &precos {
println!("R$ {preco:.2}");
}
// Alterando cada item: empresta com &mut
for preco in &mut precos {
*preco *= 1.10; // reajuste de 10%
}
for preco in &precos {
println!("Com reajuste: R$ {preco:.2}");
}
}
O & e o &mut no for são as mesmas regras de empréstimo. Sem eles, o for tomaria a posse do vetor e você não poderia usá-lo depois.
String: texto que cresce
Você já conhece a String. Ela é, por dentro, um Vec de bytes com a garantia de que o conteúdo é texto válido em UTF-8.
fn main() {
let mut mensagem = String::from("Olá");
mensagem.push_str(", Brasil"); // acrescenta um texto
mensagem.push('!'); // acrescenta um caractere
let nome = "Joana";
let idade = 29;
// format! monta uma String nova, igual ao println!, sem imprimir
let ficha = format!("{nome}, {idade} anos");
println!("{mensagem}");
println!("{ficha}");
}
Para juntar vários pedaços, prefira format!. É mais legível que somar textos com +.
Por que não dá para pegar a letra na posição 2
Em muitas linguagens, texto[2] devolve a terceira letra. No Rust, isso não compila:
fn main() {
let cidade = String::from("São Paulo");
let letra = cidade[1];
println!("{letra}");
}
error[E0277]: the type `str` cannot be indexed by `{integer}`
| let letra = cidade[1];
| ^ string indices are ranges of `usize`
O motivo é o UTF-8. Letras simples como S ocupam 1 byte. Letras acentuadas como ã ocupam 2. Um emoji ocupa 4. Então “a letra na posição 1” e “o byte na posição 1” são coisas diferentes, e o Rust se recusa a adivinhar qual você quer.
fn main() {
let cidade = "São Paulo";
println!("Bytes: {}", cidade.len()); // 10, não 9
println!("Letras: {}", cidade.chars().count()); // 9
}
Quando você quer letras, use .chars(). Ele percorre o texto caractere por caractere, cuidando dos acentos:
fn main() {
let palavra = "pão de açúcar";
for letra in palavra.chars() {
print!("[{letra}]");
}
println!();
// A terceira letra, com segurança
if let Some(letra) = palavra.chars().nth(2) {
println!("Terceira letra: {letra}");
}
// Contar vogais com acento ou sem
let vogais = palavra
.chars()
.filter(|c| "aeiouáéíóúâêôãõ".contains(*c))
.count();
println!("Vogais: {vogais}");
}
O .filter(|c| ...) usa uma closure, uma função pequena sem nome. Você vai ver isso direito na próxima lição.
HashMap: chave e valor
O HashMap guarda pares: para cada chave, um valor. Pense num cardápio: o nome do produto é a chave, o preço é o valor.
use std::collections::HashMap;
fn main() {
let mut cardapio: HashMap<String, f64> = HashMap::new();
cardapio.insert(String::from("pão francês"), 0.75);
cardapio.insert(String::from("café"), 5.50);
cardapio.insert(String::from("pão de queijo"), 4.00);
// Inserir de novo na mesma chave troca o valor
cardapio.insert(String::from("café"), 6.00);
// get devolve Option<&f64>
match cardapio.get("café") {
Some(preco) => println!("Café: R$ {preco:.2}"),
None => println!("Sem café hoje"),
}
// Percorrer: a ordem não é garantida
for (produto, preco) in &cardapio {
println!("{produto}: R$ {preco:.2}");
}
}
Dois cuidados:
- O
HashMapprecisa deuse std::collections::HashMap;. Ele não vem carregado por padrão comoVeceString. - A ordem ao percorrer muda de uma execução para outra. Se você precisa de ordem, ordene as chaves antes ou use
BTreeMap, que mantém as chaves em ordem.
Contando palavras com entry
Um uso clássico: contar quantas vezes cada palavra aparece. O método entry olha a chave; or_insert coloca um valor inicial se ela ainda não existir e devolve uma referência mutável para o valor.
use std::collections::HashMap;
fn main() {
let texto = "o pão da padaria é o melhor pão do bairro";
let mut contagem: HashMap<&str, u32> = HashMap::new();
for palavra in texto.split_whitespace() {
let total = contagem.entry(palavra).or_insert(0);
*total += 1;
}
// Ordena para a saída ficar sempre igual
let mut pares: Vec<_> = contagem.iter().collect();
pares.sort();
for (palavra, total) in pares {
println!("{palavra}: {total}");
}
}
Sem o entry, você teria que testar se a chave existe, inserir zero se não existir e depois somar. O entry().or_insert() faz tudo numa linha.
Resumo
Vec<T>é uma lista que cresce.pushacrescenta,poptira o último.v[i]causapanic!fora dos limites;v.get(i)devolveOption.- Percorra com
for x in &v(leitura) oufor x in &mut v(alteração). Stringcresce compush_strepush;format!monta textos.- Texto não é indexado por posição porque letras têm tamanhos diferentes em UTF-8. Use
.chars(). HashMapguarda chave e valor.entry(chave).or_insert(inicial)é o jeito curto de contar.
Desafio
Dada a lista de notas [("Ana", 8.0), ("Bruno", 6.5), ("Ana", 9.0), ("Carla", 7.0), ("Bruno", 7.5)], monte um HashMap<&str, Vec<f64>> com as notas de cada aluno e imprima a média de cada um, em ordem alfabética.
Ver uma resposta
use std::collections::HashMap;
fn main() {
let lancamentos = [
("Ana", 8.0),
("Bruno", 6.5),
("Ana", 9.0),
("Carla", 7.0),
("Bruno", 7.5),
];
let mut por_aluno: HashMap<&str, Vec<f64>> = HashMap::new();
for (aluno, nota) in lancamentos {
por_aluno.entry(aluno).or_insert(Vec::new()).push(nota);
}
let mut nomes: Vec<&str> = por_aluno.keys().copied().collect();
nomes.sort();
for nome in nomes {
let notas = &por_aluno[nome];
let soma: f64 = notas.iter().sum();
println!("{nome}: média {:.2}", soma / notas.len() as f64);
}
}