Java Maps

Introducción

Los Maps en Java son estructuras de datos que representan una colección de pares clave-valor. Implementan la interfaz java.util.Map y son extremadamente útiles para almacenar y recuperar datos de manera eficiente.

Creación de un Map

Existen varias implementaciones de Map en Java. Las más comunes son HashMap y TreeMap.

Map<String, Integer> mapaNombresEdades = new HashMap<>();
Map<Integer, String> mapaCodigosProductos = new TreeMap<>();

Es una buena práctica utilizar genéricos para especificar los tipos de las claves y valores. Esto es, definir el tipo de dato que se almacenará en el Map.

Inserción de elementos

Para agregar elementos a un Map, utilizamos el método put():

Map<String, List<String>> mapaEstudiantesCursos = new HashMap<>();

List<String> cursosAna = new ArrayList<>();
cursosAna.add("Matemáticas");
cursosAna.add("Física");
mapaEstudiantesCursos.put("Ana", cursosAna);

List<String> cursosCarlos = new ArrayList<>();
cursosCarlos.add("Literatura");
cursosCarlos.add("Historia");
mapaEstudiantesCursos.put("Carlos", cursosCarlos);

Inserción de múltiples elementos

Para insertar todos los elementos de un Map en otro, usamos putAll():

Map<String, Double> preciosProductosA = new HashMap<>();
preciosProductosA.put("Laptop", 999.99);
preciosProductosA.put("Smartphone", 599.99);

Map<String, Double> preciosProductosB = new HashMap<>();
preciosProductosB.putAll(preciosProductosA);
preciosProductosB.put("Tablet", 299.99);

Obtención de elementos

Para obtener un valor asociado a una clave, usamos el método get():

List<String> cursosAna = mapaEstudiantesCursos.get("Ana");
if (cursosAna != null && !cursosAna.isEmpty()) {
    String primerCursoAna = cursosAna.get(0);
    System.out.println("Primer curso de Ana: " + primerCursoAna);
}

Valor por defecto

Si no estamos seguros de que una clave exista, podemos usar getOrDefault(), que nos permite especificar un valor por defecto en caso de que la clave no exista:

List<String> cursosJuan = mapaEstCursos.getOrDefault("Juan", new ArrayList<>());
System.out.println("Cursos de Juan: " + cursosJuan);

Aquí podríamos realizar alguna acción si la lista de cursos está vacía, como agregar un mensaje de error.

Verificación de contenido

Para verificar si un Map contiene una clave o un valor específico:

boolean contieneAna = mapaEstudiantesCursos.containsKey("Ana");

boolean contieneFisica = false;
for (List<String> cursos : mapaEstudiantesCursos.values()) {
    if (cursos.contains("Física")) {
        contieneFisica = true;
        break;
    }
}

Iteración sobre un Map

Existen varias formas de iterar sobre un Map:

Usando entrySet()

for (Map.Entry<String, List<String>> entrada : mapaEstudiantesCursos.entrySet()) {
    System.out.println(entrada.getKey() + " está inscrito en: " + entrada.getValue());
}

Usando keySet() y valores

for (String estudiante : mapaEstudiantesCursos.keySet()) {
    List<String> cursos = mapaEstudiantesCursos.get(estudiante);
    System.out.println(estudiante + " está tomando " + cursos.size() + " cursos");
}

Eliminación de elementos

Para eliminar un elemento específico:

List<String> cursosEliminados = mapaEstudiantesCursos.remove("Carlos");

Para eliminar todos los elementos de un Map:

mapaEstudiantesCursos.clear();

Reemplazo de valores

El método replace() solo reemplaza el valor si la clave ya existe:

List<String> nuevosCursosAna = new ArrayList<>();
nuevosCursosAna.add("Química");
nuevosCursosAna.add("Biología");
mapaEstudiantesCursos.replace("Ana", nuevosCursosAna);

Además de reemplazar, este método también devuelve el valor anterior asociado a la clave.

Operaciones adicionales

Tamaño del Map

int numeroEstudiantes = mapaEstudiantesCursos.size();

Verificar si está vacío

boolean estaVacio = mapaEstudiantesCursos.isEmpty();

Ejemplo práctico

Veamos un ejemplo más complejo que combina varias de estas operaciones:

import java.util.*;

public class SistemaCalificaciones {
    private Map<String, Map<String, Double>> calificacionesEstudiantes;

    public SistemaCalificaciones() {
        calificacionesEstudiantes = new HashMap<>();
    }

    public void agregarCalificacion(String estudiante, String materia, Double calificacion) {
        // Si no existe el estudiante, se crea un nuevo Map para sus calificaciones
        if (!calificacionesEstudiantes.containsKey(estudiante)) {
            calificacionesEstudiantes.put(estudiante, new HashMap<>());
        }
        // Se agrega la calificación al Map correspondiente
        calificacionesEstudiantes.get(estudiante).put(materia, calificacion);
    }

    public Double obtenerPromedio(String estudiante) {
        Map<String, Double> calificaciones = calificacionesEstudiantes.get(estudiante);
        if (calificaciones == null || calificaciones.isEmpty()) {
            return 0.0;
        }
        double suma = 0.0;
        int contador = 0;
        for (Double calificacion : calificaciones.values()) {
            suma += calificacion;
            contador++;
        }
        return suma / contador;
    }

    public void imprimirCalificaciones() {
        for (String estudiante : calificacionesEstudiantes.keySet()) {
            System.out.println(estudiante + ":");
            Map<String, Double> calificaciones = calificacionesEstudiantes.get(estudiante);
            for (String materia : calificaciones.keySet()) {
                Double calificacion = calificaciones.get(materia);
                System.out.println("  " + materia + ": " + calificacion);
            }
            System.out.println("  Promedio: " + obtenerPromedio(estudiante));
        }
    }

    public static void main(String[] args) {
        SistemaCalificaciones sistema = new SistemaCalificaciones();

        sistema.agregarCalificacion("Ana", "Matemáticas", 9.5);
        sistema.agregarCalificacion("Ana", "Física", 8.7);
        sistema.agregarCalificacion("Carlos", "Literatura", 7.8);
        sistema.agregarCalificacion("Carlos", "Historia", 8.9);

        sistema.imprimirCalificaciones();
    }
}

Detalles de funcionamiento del ejemplo

El Sistema de Calificaciones implementado en este ejemplo utiliza una estructura de datos basada en Maps anidados para gestionar las calificaciones de los estudiantes. Con los componentes principales:

1. Estructura de datos:

   private Map<String, Map<String, Double>> calificacionesEstudiantes;

   • Es un Map donde la clave es el nombre del estudiante (String).
   • El valor es otro Map que representa las calificaciones del estudiante.
   • En el Map interno, la clave es el nombre de la materia (String) y el valor es la calificación (Double).

2. Métodos principales:

   a. agregarCalificacion:

   • Verifica si el estudiante ya existe en el Map principal.
   • Si no existe, crea un nuevo Map para ese estudiante.
   • Agrega la calificación al Map del estudiante.

   b. obtenerPromedio:

   • Recupera el Map de calificaciones del estudiante.
   • Calcula el promedio sumando todas las calificaciones y dividiendo por el número de materias.

   c. imprimirCalificaciones:

   • Itera sobre todos los estudiantes en el Map principal.
   • Para cada estudiante, itera sobre sus materias y calificaciones.
   • Imprime cada calificación y calcula el promedio.

3. Flujo de ejecución:

   • Se crea una instancia de SistemaCalificaciones.
   • Se agregan calificaciones para diferentes estudiantes y materias.
   • Se llama al método imprimirCalificaciones para mostrar todos los datos.

Con respecto a TreeMap, esta implementación ordena las claves de manera natural o según un comparador personalizado. Por otro lado, HashMap no garantiza ningún orden específico. Esto lo veremos al iterar sobre los elementos de un Map.