Construindo um HashMap
Insira e pesquise por chave.
Construindo um HashMap é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 1 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 é uma HashMap?
Uma HashMap armazena dados como pares de chave e valor. Você faz consultas pela chave, em vez de usar um índice.
Pense em uma lista telefônica: um nome (chave) é associado a um número (valor). HashMaps são perfeitas quando você precisa fazer consultas rápidas por uma chave significativa.
Importando HashMap
Ao contrário de Vec e String, HashMap não está no prelúdio. Você precisa trazê-la para o escopo.
Adicione uma linha use no início do seu arquivo. Isso torna o nome disponível em todo o módulo.
use std::collections::HashMap;
fn main() {
let scores: HashMap<String, i32> = HashMap::new();
println!("empty map len: {}", scores.len());
}Inserindo pares
Use insert para adicionar uma chave e seu valor. Se a chave já existir, o valor antigo será substituído.
O mapa deve ser declarado como mut para permitir a inserção.
use std::collections::HashMap;
fn main() {
let mut scores = HashMap::new();
scores.insert("Alice", 50);
scores.insert("Bob", 30);
println!("{} players", scores.len());
}Inferência de tipos
Você raramente precisa escrever o tipo. Rust infere HashMap<&str, i32> a partir das primeiras chamadas de insert.
Aqui, as chaves são fatias de strings e os valores são inteiros; tudo é determinado pelo uso.
use std::collections::HashMap;
fn main() {
let mut ages = HashMap::new();
ages.insert("Sam", 28);
ages.insert("Mia", 34);
println!("Sam is {}", ages["Sam"]);
}Obtendo valores
O método get retorna uma Option. Você obtém Some(&value) se a chave existir, ou None caso contrário.
Isso obriga você a tratar o caso ausente com segurança.
use std::collections::HashMap;
fn main() {
let mut scores = HashMap::new();
scores.insert("Alice", 50);
match scores.get("Alice") {
Some(v) => println!("score: {}", v),
None => println!("no score"),
}
}Indexação versus get
Você pode indexar com map[key], mas isso causa um panic se a chave estiver ausente.
Prefira get quando uma chave talvez não exista. Use a indexação apenas quando tiver certeza de que a chave está presente.
use std::collections::HashMap;
fn main() {
let mut m = HashMap::new();
m.insert("x", 1);
// m["y"] would panic!
let v = m.get("y").copied().unwrap_or(0);
println!("y = {}", v);
}Atualizando um valor
Chamar insert com uma chave existente sobrescreve o valor antigo.
O valor anterior é retornado (envolvido em uma Option), para que você possa inspecioná-lo se quiser.
use std::collections::HashMap;
fn main() {
let mut m = HashMap::new();
m.insert("k", 1);
let old = m.insert("k", 9);
println!("old = {:?}, now = {}", old, m["k"]);
}Verificando chaves
Use contains_key para verificar se uma chave existe sem obter seu valor.
Ele retorna um bool simples, o que é útil em condições if.
use std::collections::HashMap;
fn main() {
let mut m = HashMap::new();
m.insert("on", true);
if m.contains_key("on") {
println!("key exists");
}
}Removendo entradas
O método remove exclui uma chave e retorna seu valor como uma Option.
Se a chave não estiver presente, você obtém None; portanto, a remoção é sempre segura.
use std::collections::HashMap;
fn main() {
let mut m = HashMap::new();
m.insert("a", 1);
let removed = m.remove("a");
println!("removed {:?}, len {}", removed, m.len());
}Percorrendo um mapa
Um loop for sobre uma HashMap produz tuplas (key, value) por referência.
Observe que a ordem não é especificada e pode mudar entre execuções, pois a função de hash embaralha a disposição.
use std::collections::HashMap;
fn main() {
let mut m = HashMap::new();
m.insert("a", 1);
m.insert("b", 2);
for (k, v) in &m {
println!("{} -> {}", k, v);
}
}Propriedade das chaves
Quando você insere valores que têm propriedade, como uma String, o mapa assume a propriedade deles.
Após a inserção, você não pode usar essa variável novamente, a menos que a tenha clonado antes.
use std::collections::HashMap;
fn main() {
let mut m = HashMap::new();
let name = String::from("Alice");
m.insert(name, 50);
// name is moved here; m owns it now
println!("{}", m["Alice"]);
}Verificação rápida
Você quer um valor, mas a chave pode estar ausente.
Recapitulação
Você aprendeu a criar uma HashMap, inserir pares e consultar valores com get ou por indexação.
Você também viu contains_key, remove, iteração e como o mapa assume a propriedade das chaves inseridas.
Perguntas Frequentes
A aula “Construindo um HashMap” é grátis?
Sim — o texto completo de “Construindo um HashMap” é 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 “Construindo um HashMap”?
Insira e pesquise por chave. 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 1 de 4.
Quanto tempo leva a aula “Construindo um HashMap”?
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
- Construindo um HashMap
- API de entrada e valores padrão
- Trabalhando com HashSet
- Contagem e agrupamento