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:

use std::collections::HashMap;

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

  1. Importación: use std::collections::HashMap; importa la colección HashMap.
  2. Creación: let mut scores = HashMap::new(); crea un nuevo HashMap mutable.
  3. Inserción: scores.insert(String::from("Azul"), 10); inserta un par clave-valor en el HashMap.
  4. 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

  1. Iteración: for (key, value) in &scores itera sobre las referencias a los pares clave-valor en el HashMap.
  2. 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

  1. Actualización: scores.insert(String::from("Azul"), 25); actualiza el valor para la clave "Azul".
  2. 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

  1. Lee una cadena de texto del usuario.
  2. Divide la cadena en palabras.
  3. Usa un HashMap para contar la frecuencia de cada palabra.
  4. 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

  1. Lectura de entrada: io::stdin().read_line(&mut input).expect("Error al leer la línea"); lee una línea de texto del usuario.
  2. División en palabras: let words = input.trim().split_whitespace(); divide la cadena en palabras.
  3. Contar frecuencia: let count = word_count.entry(word).or_insert(0); *count += 1; actualiza el conteo de cada palabra en el HashMap.
  4. 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.

© Copyright 2024. Todos los derechos reservados