HashMap en Rust: El diccionario de clave-valor

Un HashMap<K, V> es una colección que almacena pares de clave-valor. Es la implementación en Rust de lo que en otros lenguajes se conoce como diccionarios o mapas. Funciona mediante una función de “hashing” que transforma una clave en un índice, permitiendo localizar el valor de forma extremadamente rápida. Para que un tipo pueda ser usado como clave (K), este debe implementar los rasgos Eq y Hash.

Se utiliza cuando necesitas buscar datos de manera eficiente basándote en un identificador único (como un ID de usuario o un nombre) en lugar de una posición numérica. Si intentas acceder a un elemento usando la sintaxis de corchetes map[&clave] y la clave no existe, el programa lanzará un panic y se detendrá inmediatamente. Por seguridad, se recomienda usar el método .get(), que devuelve un Option<&V> para manejar la ausencia de datos de forma controlada.

use std::collections::HashMap;

fn main() {
    // Crear un HashMap vacío
    let mut inventario = HashMap::new();

    // HashMap con capacidad predefinida para mejorar el rendimiento
    let mut stock_especial = HashMap::with_capacity(2);

    // Insertar elementos: insert() devuelve Option<V> (el valor anterior si existía)
    stock_especial.insert("manzanas", 10);
    let valor_anterior = stock_especial.insert("manzanas", 15); 
    println!("Valor previo de manzanas: {:?}", valor_anterior);

    // Usar HashMap::from para crear un mapa desde un array de tuplas
    let mut precios = HashMap::from([
        ("pan", 1.50),
        ("leche", 0.99),
        ("huevo", 0.15),
    ]);

    // Acceso seguro con .get() -> devuelve Option<&V>
    let buscar_pan = precios.get("pan");
    println!("Precio del pan: {:?}", buscar_pan);

    // Verificar si una clave existe
    if precios.contains_key("leche") {
        println!("La leche está disponible.");
    }

    // Eliminar un elemento: remove() devuelve Option<V>
    let item_eliminado = precios.remove("huevo");
    println!("Elemento eliminado: {:?}", item_eliminado);

    // Iterar sobre el HashMap (referencias)
    println!("--- Lista de productos y precios ---");
    for (producto, precio) in &precios {
        println!("{}: ${}", producto, precio);
    }

    // Información de la colección
    println!("Cantidad de items: {}", precios.len());
    println!("¿Está vacío?: {}", precios.is_empty());

    // Limpiar toda la colección
    precios.clear();
    println!("¿Está vacío tras clear?: {}", precios.is_empty());
}

Explicación del Código

– HashMap::new(): Crea un mapa vacío sin asignar memoria inicialmente.
– HashMap::with_capacity(2): Crea un mapa reservando espacio para 2 elementos, evitando reasignaciones de memoria costosas.
– stock_especial.insert("manzanas", 15): Inserta la clave "manzanas". Como ya existía el valor 10, valor_anterior recibe Some(10).
– HashMap::from(...): Permite la inicialización rápida usando una lista de tuplas.
– precios.get("pan"): Busca la clave "pan". Devuelve Some(&1.50) si existe o None si no.
– precios.contains_key("leche"): Devuelve true si la clave "leche" está presente.
– precios.remove("huevo"): Elimina la entrada "huevo" y devuelve su valor en un Some(0.15).
– for (producto, precio) in &precios: Itera sobre las claves y valores por referencia para no tomar la propiedad (ownership) del mapa.
– precios.len(): Devuelve el número actual de elementos en el mapa.
– precios.is_empty(): Devuelve true si no hay elementos.
– precios.clear(): Elimina todos los elementos del mapa, dejándolo vacío.

N° 72