En este tema, aprenderemos sobre los HashMaps en Rust, una estructura de datos que permite almacenar pares clave-valor. Los HashMaps son útiles cuando necesitas asociar una clave única con un valor y luego recuperar ese valor de manera eficiente.
¿Qué es un HashMap?
Un HashMap es una colección de pares clave-valor, donde cada clave es única. Los HashMaps son implementados en Rust a través de la biblioteca estándar std::collections::HashMap
.
Características de los HashMaps:
- Claves únicas: Cada clave en un HashMap debe ser única.
- Acceso rápido: Los HashMaps permiten un acceso rápido a los valores mediante sus claves.
- Orden no garantizado: Los elementos en un HashMap no tienen un orden garantizado.
Creación de un HashMap
Para usar un HashMap, primero necesitas importar la colección desde la biblioteca estándar:
Ejemplo básico
A continuación, se muestra cómo crear un HashMap, insertar elementos y acceder a ellos:
use std::collections::HashMap; fn main() { // Crear un nuevo HashMap let mut scores = HashMap::new(); // Insertar algunos pares clave-valor scores.insert(String::from("Azul"), 10); scores.insert(String::from("Rojo"), 50); // Acceder a un valor usando su clave let team_name = String::from("Azul"); match scores.get(&team_name) { Some(score) => println!("El puntaje del equipo {} es {}", team_name, score), None => println!("No se encontró el equipo {}", team_name), } }
Explicación del código
- Importación:
use std::collections::HashMap;
importa la colección HashMap. - Creación:
let mut scores = HashMap::new();
crea un nuevo HashMap mutable. - Inserción:
scores.insert(String::from("Azul"), 10);
inserta un par clave-valor en el HashMap. - Acceso:
scores.get(&team_name)
devuelve una opción (Option<&V>
) que contiene el valor asociado con la clave, si existe.
Iteración sobre un HashMap
Puedes iterar sobre los pares clave-valor en un HashMap usando un bucle for
:
use std::collections::HashMap; fn main() { let mut scores = HashMap::new(); scores.insert(String::from("Azul"), 10); scores.insert(String::from("Rojo"), 50); for (key, value) in &scores { println!("Equipo: {}, Puntaje: {}", key, value); } }
Explicación del código
- Iteración:
for (key, value) in &scores
itera sobre las referencias a los pares clave-valor en el HashMap. - Impresión:
println!("Equipo: {}, Puntaje: {}", key, value);
imprime cada par clave-valor.
Actualización de Valores
Puedes actualizar el valor asociado con una clave existente o insertar un nuevo par clave-valor si la clave no existe:
use std::collections::HashMap; fn main() { let mut scores = HashMap::new(); scores.insert(String::from("Azul"), 10); // Actualizar el valor para la clave "Azul" scores.insert(String::from("Azul"), 25); // Insertar un nuevo par clave-valor si la clave no existe scores.entry(String::from("Verde")).or_insert(30); println!("{:?}", scores); }
Explicación del código
- Actualización:
scores.insert(String::from("Azul"), 25);
actualiza el valor para la clave "Azul". - Inserción condicional:
scores.entry(String::from("Verde")).or_insert(30);
inserta el par clave-valor solo si la clave "Verde" no existe.
Ejercicio Práctico
Ejercicio
Crea un programa que lea una lista de palabras y cuente la frecuencia de cada palabra usando un HashMap.
Instrucciones
- Lee una cadena de texto del usuario.
- Divide la cadena en palabras.
- Usa un HashMap para contar la frecuencia de cada palabra.
- Imprime el HashMap.
Solución
use std::collections::HashMap; use std::io; fn main() { // Leer la entrada del usuario println!("Introduce una cadena de texto:"); let mut input = String::new(); io::stdin().read_line(&mut input).expect("Error al leer la línea"); // Dividir la cadena en palabras let words = input.trim().split_whitespace(); // Crear un HashMap para contar la frecuencia de las palabras let mut word_count = HashMap::new(); // Contar la frecuencia de cada palabra for word in words { let count = word_count.entry(word).or_insert(0); *count += 1; } // Imprimir el HashMap println!("{:?}", word_count); }
Explicación del código
- Lectura de entrada:
io::stdin().read_line(&mut input).expect("Error al leer la línea");
lee una línea de texto del usuario. - División en palabras:
let words = input.trim().split_whitespace();
divide la cadena en palabras. - Contar frecuencia:
let count = word_count.entry(word).or_insert(0); *count += 1;
actualiza el conteo de cada palabra en el HashMap. - Impresión:
println!("{:?}", word_count);
imprime el HashMap.
Conclusión
En esta sección, hemos aprendido sobre los HashMaps en Rust, cómo crearlos, insertar y acceder a elementos, iterar sobre ellos y actualizar valores. También hemos visto un ejemplo práctico para contar la frecuencia de palabras en una cadena de texto. Con esta base, estarás preparado para utilizar HashMaps en tus propios proyectos de Rust.
Curso de Programación en Rust
Módulo 1: Introducción a Rust
- ¿Qué es Rust?
- Configuración del Entorno de Rust
- Programa "Hola, Mundo!"
- Sintaxis y Estructura Básica