Mapas en Java

En Java, los mapas representan estructuras de datos que asocian claves con valores, lo que permite almacenar, acceder, actualizar y eliminar pares clave-valor de forma eficiente. A diferencia de las colecciones que almacenan únicamente elementos, los mapas mantienen una relación de mapeo en la que cada clave es única y apunta exactamente a un valor, aunque los valores pueden repetirse.

La interfaz Map proporciona mecanismos para obtener valores a partir de claves únicas (no duplicadas). La interfaz Map proporciona tres vistas de colecciones que permiten manipular el contenido del mapa de diferentes formas: un conjunto de claves, una colección de valores o un conjunto de asociaciones entre claves y valores. La principal interfaz derivada de Map es SortedMap, que representa mapas ordenados, y su subinterfaz NavigableMap. Map es ampliamente utilizada por las clases de la biblioteca estándar del lenguaje. Las principales clases que implementan la interfaz Map para mapas no concurrentes son HashMap, LinkedHashMap y TreeMap. Para mapas concurrentes, destacan ConcurrentHashMap y ConcurrentSkipListMap.

A continuación, se muestra parte de la definición de la interfaz Map, que contiene únicamente los métodos principales:

public interface Map<K,V>{
    // Operaciones de consulta
    int size();
    boolean isEmpty();
    boolean containsKey(Object key);
    boolean containsValue(Object value);
    V get(Object key);

    // Operaciones de modificación
    V put(K key, V value);
    V remove(Object key);
    void putAll(Map<? extends K, ? extends V> m);
    void clear();

    // Vistas
    Set<K> keySet();
    Collection<V> values();
    Set<Map.Entry<K, V>> entrySet();

    // Definición de la interfaz Entry
    interface Entry<K, V> {
        // Cuerpo omitido
    }

    // (continúa...)
}

El siguiente ejemplo muestra un mapa de automóviles cuyas claves son las matrículas y cuyos valores son los nombres de los modelos de los automóviles correspondientes. Con este mapa podemos, por ejemplo, comprobar la existencia de un elemento determinado utilizando la clave como parámetro del método containsKey. Además, el método get obtiene el valor asociado a la clave pasada como parámetro y el método remove elimina la entrada del mapa:

void main() {
    Map<String, String> coches = new HashMap<>();
    coches.put("ABCD2935", "Tesla Model S");
    coches.put("YJKF9353", "Toyota Corolla");
    coches.put("WFLO1304", "Honda CRV");

    var key = "ABCD2935";

    if (coches.containsKey(key)){
        IO.println("Datos del vehículo:");
        IO.println(coches.get(key));
        IO.println("Eliminando el vehículo...");
        coches.remove(key);
    } else
        IO.println("Vehículo no encontrado!");
}

La salida sería:

Datos del vehículo:
Tesla Model S
Eliminando el vehículo...

Además de los métodos descritos anteriormente, también existen varios métodos default que implementan funcionalidades adicionales.

La interfaz también proporciona métodos para crear mapas inmutables a partir de valores proporcionados (los métodos of y ofEntries, junto con el método auxiliar entry) o a partir de un mapa existente (copyOf).

La Figura 1 muestra la interfaz Map y sus principales subinterfaces. Las subinterfaces directas de Map son SequencedMap, Bindings y ConcurrentMap. Indirectamente, también son interfaces derivadas de Map las interfaces SortedMap, NavigableMap y ConcurrentNavigableMap (esta última también es subinterfaz de ConcurrentMap).

Entre las descendientes más importantes de Map se encuentran las interfaces SortedMap y NavigableMap.

La interfaz SortedMap es una extensión de la interfaz SequencedMap que representa mapas que mantienen las claves en un orden específico, de acuerdo con el orden natural de las claves o con un comparador específico proporcionado durante la creación del mapa. Su única subinterfaz directa en el framework de colecciones, NavigableMap, añade métodos que proporcionan operaciones de navegación más avanzadas para manipular las claves del mapa, como obtener la clave más cercana a un valor específico o recorrer el mapa en orden ascendente o descendente.

Comúnmente, utilizamos NavigableMap en lugar de SortedMap, ya que ambas clases que implementan SortedMap en el framework de colecciones lo hacen indirectamente (TreeMap implementa NavigableMap, y ConcurrentSkipListMap implementa ConcurrentNavigableMap). NavigableMap va un poco más allá en términos de funcionalidad, proporcionando métodos específicos para navegar por el mapa, de manera análoga a lo que NavigableSet proporciona para conjuntos.

---

Este artículo es una adaptación de contenido del libro Orientação a Objetos com Java, de Eduardo Kessler Piveta