Learn Rust Coding · Aula

HashMaps

Armazenamento de chave e valor

HashMaps é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

O que é um HashMap

Um HashMap<K, V> armazena pares de chave e valor. Você consulta os valores pela chave, em vez de pela posição.

É necessário importá-lo da biblioteca padrão.

use std::collections::HashMap;

fn main() {
    let map: HashMap<String, i32> = HashMap::new();
    println!("{} entries", map.len());
}

Importando HashMap

HashMap não está no preâmbulo; portanto, adicione esta linha no início do seu arquivo:

use std::collections::HashMap;

use std::collections::HashMap;

fn main() {
    let scores: HashMap<&str, i32> = HashMap::new();
    println!("empty: {}", scores.is_empty());
}

Inserindo pares

Adicione entradas com insert, fornecendo uma chave e um valor. O mapa deve ser mut.

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert("Alice", 90);
    scores.insert("Bob", 85);
    println!("{:?}", scores);
}

Consultando valores

Use get para ler um valor pela chave. Ele retorna um Option — Some(value) se encontrar a chave e None caso contrário.

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert("Alice", 90);
    match scores.get("Alice") {
        Some(s) => println!("score {}", s),
        None => println!("not found"),
    }
}

Atualizando um valor

Chamar insert com uma chave existente substitui o valor antigo.

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("count", 1);
    map.insert("count", 5); // overwrites
    println!("{:?}", map.get("count"));
}

Inserindo somente se ausente

A API entry com or_insert insere um valor padrão somente se a chave estiver ausente.

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.entry("x").or_insert(10);
    map.entry("x").or_insert(99); // ignored, key exists
    println!("{:?}", map.get("x"));
}

Contando com entry

Um padrão clássico: conte ocorrências obtendo uma referência mutável com or_insert e incrementando-a.

use std::collections::HashMap;

fn main() {
    let text = "a b a c b a";
    let mut counts = HashMap::new();
    for word in text.split_whitespace() {
        let c = counts.entry(word).or_insert(0);
        *c += 1;
    }
    println!("{:?}", counts);
}

Percorrendo entradas

Percorra um HashMap para visitar cada par de chave e valor. A ordem não é garantida.

use std::collections::HashMap;

fn main() {
    let mut ages = HashMap::new();
    ages.insert("Tom", 30);
    ages.insert("Sue", 25);
    for (name, age) in &ages {
        println!("{} is {}", name, age);
    }
}

Removendo entradas

Exclua um par com remove. Ele retorna o valor removido como um Option.

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("key", 42);
    let removed = map.remove("key");
    println!("removed {:?}, len {}", removed, map.len());
}

Verificando uma chave

Use contains_key para verificar se uma chave existe sem recuperar seu valor.

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("on", true);
    println!("{}", map.contains_key("on"));
    println!("{}", map.contains_key("off"));
}

Valor padrão com unwrap_or

Ao ler, você pode fornecer um valor alternativo com unwrap_or em vez de fazer correspondência com o Option.

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("a", 1);
    let value = map.get("missing").unwrap_or(&0);
    println!("{}", value);
}

Verificação rápida

Recorde como funcionam as consultas em HashMap.

Recapitulação

HashMaps em Rust:

HashMap<K, V> armazena pares de chave e valor; importe-o de std::collections.
insert adiciona ou sobrescreve; get retorna um Option.
entry().or_insert() insere somente se a chave estiver ausente.
Itere com for (k, v) in &map.

use std::collections::HashMap;

fn main() {
    let mut inventory = HashMap::new();
    inventory.insert("apples", 3);
    *inventory.entry("apples").or_insert(0) += 2;
    println!("{:?}", inventory.get("apples"));
}

Perguntas Frequentes

A aula “HashMaps” é grátis?

Sim — o texto completo de “HashMaps” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “HashMaps”?

Armazenamento de chave e valor Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “HashMaps”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding