Pular para o conteúdo
Rust em Português

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 HashMap precisa de use std::collections::HashMap;. Ele não vem carregado por padrão como Vec e String.
  • 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. push acrescenta, pop tira o último.
  • v[i] causa panic! fora dos limites; v.get(i) devolve Option.
  • Percorra com for x in &v (leitura) ou for x in &mut v (alteração).
  • String cresce com push_str e push; format! monta textos.
  • Texto não é indexado por posição porque letras têm tamanhos diferentes em UTF-8. Use .chars().
  • HashMap guarda 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);
    }
}
Salvo só neste navegador.