El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

HashMap

Siguiente ►
►

Introducción

En Java, HashMap es una implementación de la interfaz Map que utiliza una tabla hash para almacenar pares clave-valor. Es una de las estructuras de datos más utilizadas debido a su eficiencia en operaciones de inserción, búsqueda y eliminación.

Características de HashMap:

  • No permite claves duplicadas: Cada clave en un HashMap debe ser única.
  • Permite valores nulos: Tanto las claves como los valores pueden ser nulos.
  • No garantiza el orden: Los elementos no se almacenan en el orden en que se insertan.

Creación de un HashMap

Para crear un HashMap, primero debes importar la clase desde el paquete java.util.

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // Crear un HashMap
        HashMap<Integer, String> map = new HashMap<>();
    }
}

Operaciones Básicas

Insertar Elementos

Puedes insertar elementos en un HashMap utilizando el método put.

map.put(1, "Uno");
map.put(2, "Dos");
map.put(3, "Tres");

Obtener Elementos

Para obtener un valor asociado a una clave, utiliza el método get.

String value = map.get(1); // Devuelve "Uno"

Eliminar Elementos

Para eliminar un par clave-valor, utiliza el método remove.

map.remove(2); // Elimina el par con clave 2

Verificar la Existencia de una Clave o Valor

Puedes verificar si una clave o un valor existe en el HashMap utilizando los métodos containsKey y containsValue.

boolean hasKey = map.containsKey(1); // Devuelve true
boolean hasValue = map.containsValue("Dos"); // Devuelve false

Iterar sobre un HashMap

Puedes iterar sobre las claves, valores o pares clave-valor de un HashMap utilizando un bucle for-each.

// Iterar sobre las claves
for (Integer key : map.keySet()) {
    System.out.println("Clave: " + key);
}

// Iterar sobre los valores
for (String value : map.values()) {
    System.out.println("Valor: " + value);
}

// Iterar sobre los pares clave-valor
for (Map.Entry<Integer, String> entry : map.entrySet()) {
    System.out.println("Clave: " + entry.getKey() + ", Valor: " + entry.getValue());
}

Ejemplo Práctico

Vamos a crear un programa que almacene y gestione un directorio telefónico utilizando un HashMap.

import java.util.HashMap;
import java.util.Map;

public class DirectorioTelefonico {
    public static void main(String[] args) {
        // Crear un HashMap para almacenar el directorio telefónico
        HashMap<String, String> directorio = new HashMap<>();

        // Agregar contactos
        directorio.put("Juan", "123-456-7890");
        directorio.put("María", "234-567-8901");
        directorio.put("Pedro", "345-678-9012");

        // Obtener y mostrar el número de teléfono de Juan
        String numeroJuan = directorio.get("Juan");
        System.out.println("Número de Juan: " + numeroJuan);

        // Eliminar el contacto de Pedro
        directorio.remove("Pedro");

        // Verificar si María está en el directorio
        boolean tieneMaria = directorio.containsKey("María");
        System.out.println("¿Está María en el directorio? " + tieneMaria);

        // Mostrar todos los contactos
        for (Map.Entry<String, String> contacto : directorio.entrySet()) {
            System.out.println("Nombre: " + contacto.getKey() + ", Número: " + contacto.getValue());
        }
    }
}

Ejercicio Práctico

Ejercicio 1: Gestión de Inventario

Crea un programa que gestione un inventario de productos utilizando un HashMap. El programa debe permitir:

  1. Agregar productos con su cantidad.
  2. Actualizar la cantidad de un producto existente.
  3. Eliminar un producto del inventario.
  4. Mostrar todos los productos y sus cantidades.

Solución

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Inventario {
    public static void main(String[] args) {
        HashMap<String, Integer> inventario = new HashMap<>();
        Scanner scanner = new Scanner(System.in);
        int opcion;

        do {
            System.out.println("1. Agregar producto");
            System.out.println("2. Actualizar cantidad");
            System.out.println("3. Eliminar producto");
            System.out.println("4. Mostrar inventario");
            System.out.println("5. Salir");
            System.out.print("Elige una opción: ");
            opcion = scanner.nextInt();
            scanner.nextLine(); // Consumir el salto de línea

            switch (opcion) {
                case 1:
                    System.out.print("Nombre del producto: ");
                    String producto = scanner.nextLine();
                    System.out.print("Cantidad: ");
                    int cantidad = scanner.nextInt();
                    inventario.put(producto, cantidad);
                    break;
                case 2:
                    System.out.print("Nombre del producto: ");
                    producto = scanner.nextLine();
                    if (inventario.containsKey(producto)) {
                        System.out.print("Nueva cantidad: ");
                        cantidad = scanner.nextInt();
                        inventario.put(producto, cantidad);
                    } else {
                        System.out.println("Producto no encontrado.");
                    }
                    break;
                case 3:
                    System.out.print("Nombre del producto: ");
                    producto = scanner.nextLine();
                    inventario.remove(producto);
                    break;
                case 4:
                    for (Map.Entry<String, Integer> entry : inventario.entrySet()) {
                        System.out.println("Producto: " + entry.getKey() + ", Cantidad: " + entry.getValue());
                    }
                    break;
                case 5:
                    System.out.println("Saliendo...");
                    break;
                default:
                    System.out.println("Opción no válida.");
            }
        } while (opcion != 5);

        scanner.close();
    }
}

Conclusión

En esta sección, hemos aprendido sobre HashMap, una estructura de datos eficiente para almacenar y gestionar pares clave-valor. Hemos cubierto las operaciones básicas, como insertar, obtener, eliminar y verificar elementos, así como iterar sobre el HashMap. Además, hemos visto un ejemplo práctico y un ejercicio para reforzar los conceptos aprendidos. En el próximo módulo, exploraremos otras estructuras de datos y colecciones en Java.

◄ Anterior
◄
Siguiente ►
►

Curso de Programación en Java

Módulo 1: Introducción a Java

Módulo 2: Flujo de Control

Módulo 3: Programación Orientada a Objetos

Módulo 4: Programación Orientada a Objetos Avanzada

Módulo 5: Estructuras de Datos y Colecciones

Módulo 6: Manejo de Excepciones

Módulo 7: Entrada/Salida de Archivos

Módulo 8: Multihilo y Concurrencia

Módulo 9: Redes

Módulo 10: Temas Avanzados

Módulo 11: Frameworks y Librerías de Java

Módulo 12: Construcción de Aplicaciones del Mundo Real

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados