feat(content): add basic hashmap

Author: SergioRibera

content/2.basic/30.hashmap.md

@@ -0,0 +1,146 @@
+---
+title: 'HashMap'
+description: 'Explorando HashMap en Rust: Almacenamiento y Manipulación Eficiente de Datos Asociativos'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'medium'
+  position:
+    x: 120
+    y: 600
+  # width: 320
+  externalLinks:
+    - name: 'Libro Oficial'
+      english: false
+      link: 'https://book.rustlang-es.org/ch08-03-hash-maps'
+    - name: 'Comprehensive Rust'
+      english: true
+      link: 'https://google.github.io/comprehensive-rust/es/std-types/hashmap.html'
+    - name: 'Documentacion Oficial'
+      english: true
+      link: 'https://doc.rust-lang.org/std/collections/struct.HashMap.html'
+---
+## HashMap en Rust: Almacenamiento y Manipulación Eficiente de Datos Asociativos
+
+En Rust, el tipo `HashMap<K, V>` es una colección poderosa que permite almacenar pares clave-valor de manera eficiente. Los `HashMap` son ampliamente utilizados cuando se necesita un acceso rápido y eficiente a los datos basados en claves únicas. En este blog post, exploraremos el funcionamiento de los `HashMap` en Rust, cómo se utilizan, su representación en memoria, sus ventajas, y algunos patrones de uso comunes.
+
+### ¿Qué es un `HashMap<K, V>`?
+
+Un `HashMap<K, V>` es una colección que almacena pares clave-valor, donde cada clave es única y se asocia con un valor. Este tipo de datos es ideal para situaciones en las que se necesita acceder, insertar o eliminar elementos rápidamente mediante una clave.
+
+### Funcionamiento en Memoria
+
+Internamente, un `HashMap<K, V>` se implementa utilizando una tabla hash. La clave se pasa a través de una función hash para determinar la ubicación en la tabla donde se almacenará el valor correspondiente. Esto permite operaciones de búsqueda, inserción y eliminación muy eficientes.
+
+#### Gráfico: Representación en Memoria de un `HashMap<K, V>`
+
+```plaintext
+HashMap:
++-------+------+-------+------+
+| Clave | Hash | Índice | Valor |
++-------+------+-------+------+
+| "a"   | 1234 | 0     | 10   |
+| "b"   | 5678 | 1     | 20   |
+| "c"   | 9101 | 2     | 30   |
++-------+------+-------+------+
+```
+
+### Creación y Uso de `HashMap<K, V>`
+
+Crear y manipular un `HashMap<K, V>` en Rust es sencillo. A continuación, se muestran algunos ejemplos básicos:
+
+#### Ejemplo 1: Creación y Adición de Elementos
+
+```rust
+use std::collections::HashMap;
+
+fn main() {
+    let mut mapa = HashMap::new(); // Crear un nuevo HashMap vacío
+    mapa.insert("clave1", 10); // Insertar pares clave-valor
+    mapa.insert("clave2", 20);
+    mapa.insert("clave3", 30);
+
+    println!("{:?}", mapa); // Output: {"clave1": 10, "clave2": 20, "clave3": 30}
+}
+```
+
+#### Ejemplo 2: Acceso a Elementos
+
+```rust
+use std::collections::HashMap;
+
+fn main() {
+    let mut mapa = HashMap::new();
+    mapa.insert("clave1", 10);
+    mapa.insert("clave2", 20);
+
+    if let Some(valor) = mapa.get("clave1") {
+        println!("El valor para 'clave1' es: {}", valor); // Output: El valor para 'clave1' es: 10
+    }
+}
+```
+
+#### Ejemplo 3: Iteración sobre un `HashMap<K, V>`
+
+```rust
+use std::collections::HashMap;
+
+fn main() {
+    let mut mapa = HashMap::new();
+    mapa.insert("clave1", 10);
+    mapa.insert("clave2", 20);
+    mapa.insert("clave3", 30);
+
+    for (clave, valor) in &mapa {
+        println!("Clave: {}, Valor: {}", clave, valor);
+    }
+}
+```
+
+### Ventajas de Usar `HashMap<K, V>`
+
+- **Acceso Rápido:** Los `HashMap` proporcionan un acceso constante promedio O(1) a los valores mediante sus claves, lo que los hace muy eficientes para búsquedas rápidas.
+- **Flexibilidad:** Permiten almacenar pares clave-valor de cualquier tipo, siempre que las claves implementen las traits `Eq` y `Hash`.
+- **Versatilidad:** Son útiles en una amplia gama de aplicaciones, desde bases de datos simples hasta sistemas de caché y configuraciones.
+
+### Métodos Comunes de `HashMap<K, V>`
+
+- `insert()`: Añade un par clave-valor al `HashMap`.
+- `get()`: Recupera un valor asociado con una clave específica.
+- `remove()`: Elimina un par clave-valor del `HashMap`.
+- `contains_key()`: Verifica si una clave está presente en el `HashMap`.
+- `entry()`: Proporciona una manera eficiente de insertar o modificar un valor basado en una clave.
+
+#### Ejemplo: Métodos Comunes
+
+```rust
+use std::collections::HashMap;
+
+fn main() {
+    let mut mapa = HashMap::new();
+    mapa.insert("clave1", 10);
+
+    // Verificar si una clave existe
+    if mapa.contains_key("clave1") {
+        println!("'clave1' existe en el mapa.");
+    }
+
+    // Uso de entry para insertar o modificar un valor
+    mapa.entry("clave2").or_insert(20);
+    mapa.entry("clave1").and_modify(|v| *v += 10);
+
+    println!("{:?}", mapa); // Output: {"clave1": 20, "clave2": 20}
+}
+```
+
+### Diferencia con Otros Tipos de Colección
+
+A diferencia de los vectores (`Vec<T>`), que almacenan elementos en un orden específico y permiten el acceso mediante índices, los `HashMap` almacenan elementos en base a claves únicas y permiten el acceso mediante estas claves. Esto los hace más adecuados para aplicaciones donde se necesita acceso rápido a valores específicos basados en claves, en lugar de operaciones de secuencia ordenada.
+
+### Coste Computacional de `HashMap<K, V>`
+
+El uso de `HashMap` implica un coste computacional para calcular las funciones hash y manejar posibles colisiones. Sin embargo, Rust optimiza estas operaciones para mantener el acceso a los datos lo más eficiente posible. La mayoría de las operaciones tienen un coste promedio de O(1), lo que las hace muy eficientes en la práctica.
+
+### Conclusión
+
+`HashMap<K, V>` es una herramienta esencial en Rust para trabajar con colecciones de datos asociativos. Su flexibilidad, eficiencia y compatibilidad con las claves únicas lo hacen adecuado para una amplia gama de aplicaciones. Al comprender cómo funciona `HashMap<K, V>` en memoria, sus ventajas y cómo utilizar sus métodos comunes, los desarrolladores pueden aprovechar al máximo las capacidades de Rust para manejar datos de manera efectiva y segura.