Tema 2.5 - Mapas

La interfaz map nos representa una asignación entre una clave o llave y un valor. Aunque muchas veces se hable de los mapas como una colección, en realidad no lo son, ya que como observamos en el capitulo de colecciones los mapas no heredan de la interfaz Collection, como los otros.

Algunas de las características de la interfaz de mapa son:

1. Un mapa no puede tener claves duplicadas y cada clave puede asignarse a un máximo de un valor.
2. Algunas implementaciones permiten una clave nula y un valor nulo como el HashMap y LinkedHashMap, pero existen algunas que no como el TreeMap
3. Hay dos interfaces para implementar Map en java: Map y SortedMap , y tres clases: HashMap , TreeMap y LinkedHashMap
   

¿Por qué y cuándo usamos los mapas?

Los mapas son perfectos para usar en el mapeo de asociación clave-valor, como los diccionarios. Los mapas se utilizan para realizar búsquedas por claves o cuando alguien quiere recuperar y actualizar elementos por claves. Veamos algunos ejemplos donde podemos utilizar los mapas:

• Un mapa de códigos de error y sus descripciones
• Un mapa de códigos postales y ciudades
• Un mapa de directivos y empleados. Cada administrador (clave) está asociado con una lista de empleados (valor) que administra
• Un mapa de clases y alumnos. Cada clase (clave) está asociada con una lista de alumnos (valor)

Métodos Básicos:

• get(Object clave): nos devuelve el valor asociado a la clave indicada
  
• put(Object clave, Object valor): nos permite insertar una nueva clave con el valor especificado. Nos devuelve el valor que tenía antes dicha clave, o null si la clave no estaba en la tabla todavía
  
• remove(Object clave): con este podemos eliminar una clave, devolviendonos el valor que tenía dicha clave
  
• keySet(): nos devuelve el conjunto de claves registradas
  
• size(): nos devuelve el número de parejas (clave,valor) registradas.

Como en los casos anteriores el map también posee varias implementaciones. Visto esto vamos a poner un ejemplo para cada una de las implementaciones y como ordena los elementos. Para este ejemplo vamos a tener un Map en el que la clave va a ser el dorsal de los jugadores de fútbol de la selección española que jugaron de titulares la final de la copa del mundo de 2010, y su valor va a ser su nombre.

HashMap:

Los elementos que inserta en el map no tendrán un orden específico. No aceptan claves duplicadas ni valores nulos. Debemos tener en cuenta el coste de la iteración dependerá del número de entradas de la tabla y del número de elementos del mapa.

Ahora vamos a dar un vistazo al ejemplo mencionado anteriormente de los jugadores de fútbol realizado con el HashMap.

import java.util.*;  

public class MapPrueba{  
    public static void main(String[] args) 
    { 
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "Casillas");     map.put(15, "Ramos");
        map.put(3, "Pique");        map.put(5, "Puyol");
        map.put(11, "Capdevila");   map.put(14, "Xabi Alonso");
        map.put(16, "Busquets");    map.put(8, "Xavi Hernandez");
        map.put(18, "Pedrito");     map.put(6, "Iniesta");
        map.put(7, "Villa");

        // Imprimimos el Map con un Iterador
        Iterator it = map.keySet().iterator();
        while(it.hasNext()){
          Integer key = (Integer) it.next();
          System.out.println("Clave: " + key + " -> Valor: " + map.get(key));
        } 
    } 
}

El resultado que tenemos es el siguiente, en el que vemos que nos da los objetos sin un "orden lógico":

Clave: 16 -> Valor: Busquets
Clave: 1 -> Valor: Casillas
Clave: 18 -> Valor: Pedrito
Clave: 3 -> Valor: Pique
Clave: 5 -> Valor: Puyol
Clave: 6 -> Valor: Iniesta
Clave: 7 -> Valor: Villa
Clave: 8 -> Valor: Xavi Hernandez
Clave: 11 -> Valor: Capdevila
Clave: 14 -> Valor: Xabi Alonso
Clave: 15 -> Valor: Ramos

TreeMap:

El Mapa lo ordena de forma "natural". Por ejemplo, si la clave son valores enteros (como luego veremos), los ordena de menor a mayor. El coste de las operaciones básicas será logarítmico con el número de elementos del mapa O(log n).

Ahora vamos a dar un vistazo al ejemplo mencionado anteriormente de los jugadores de fútbol realizado con el TreeMap

import java.util.*;  

public class MapPrueba{  
    public static void main(String[] args) 
    { 
        Map<Integer, String> treeMap = new TreeMap<Integer, String>();
        treeMap.put(1, "Casillas"); treeMap.put(15, "Ramos");
        treeMap.put(3, "Pique");    treeMap.put(5, "Puyol");
        treeMap.put(11, "Capdevila");   treeMap.put(14, "Xabi Alonso");
        treeMap.put(16, "Busquets");    treeMap.put(8, "Xavi Hernandez");
        treeMap.put(18, "Pedrito"); treeMap.put(6, "Iniesta");
        treeMap.put(7, "Villa");

        // Imprimimos el Map con un Iterador que ya hemos instanciado anteriormente
        Iterator it = treeMap.keySet().iterator();
        while(it.hasNext()){
          Integer key = (Integer) it.next();
          System.out.println("Clave: " + key + " -> Valor: " + treeMap.get(key));
        }
    } 
}

El resultado que tenemos es el siguiente en el que vemos que nos ordena los objetos por clave en "orden natural":

Clave: 1 -> Valor: Casillas
Clave: 3 -> Valor: Pique
Clave: 5 -> Valor: Puyol
Clave: 6 -> Valor: Iniesta
Clave: 7 -> Valor: Villa
Clave: 8 -> Valor: Xavi Hernandez
Clave: 11 -> Valor: Capdevila
Clave: 14 -> Valor: Xabi Alonso
Clave: 15 -> Valor: Ramos
Clave: 16 -> Valor: Busquets
Clave: 18 -> Valor: Pedrito

LinkedHashMap:

Inserta en el Map los elementos en el orden en el que se van insertando; es decir, que no tenemos un orden de los elementos como tal, por lo que esta clase realiza las búsquedas de los elementos de forma más lenta que las demás clases

Ahora vamos a dar un vistazo al ejemplo mencionado anteriormente de los jugadores de fútbol realizado con el LinkedHashMap

import java.util.*;  

public class MapPrueba{  
    public static void main(String[] args) 
    { 
        Map<Integer, String> linkedHashMap = new LinkedHashMap<Integer, String>();
        linkedHashMap.put(1, "Casillas");   linkedHashMap.put(15, "Ramos");
        linkedHashMap.put(3, "Pique");      linkedHashMap.put(5, "Puyol");
        linkedHashMap.put(11, "Capdevila"); linkedHashMap.put(14, "Xabi Alonso");
        linkedHashMap.put(16, "Busquets");  linkedHashMap.put(8, "Xavi Hernandez");
        linkedHashMap.put(18, "Pedrito");   linkedHashMap.put(6, "Iniesta");
        linkedHashMap.put(7, "Villa");

        // Imprimimos el Map con un Iterador que ya hemos instanciado anteriormente
        Iterator it = linkedHashMap.keySet().iterator();
        while(it.hasNext()){
          Integer key = (Integer) it.next();
          System.out.println("Clave: " + key + " -> Valor: " + linkedHashMap.get(key));
        }
    } 
}  

El resultado que tenemos es el siguiente en el que vemos que nos ordena los objetos tal y como los hemos ido introduciendo:

Clave: 1  -> Valor: Casillas
Clave: 15 -> Valor: Ramos
Clave: 3  -> Valor: Pique
Clave: 5  -> Valor: Puyol
Clave: 11 -> Valor: Capdevila
Clave: 14 -> Valor: Xabi Alonso
Clave: 16 -> Valor: Busquets
Clave: 8  -> Valor: Xavi Hernandez
Clave: 18 -> Valor: Pedrito
Clave: 6  -> Valor: Iniesta
Clave: 7  -> Valor: Villa

En esta parte del curso observamos una parte del manejo de mapas, de las cuales visualizamos como son utilizadas en Java. Ahora tu puedes seguir trabajando y revisando con algunos ejemplos de como utilizarlos.

Nota: para este tema es importante probar el código escrito en un compilador de Java, podemos probar el código en el compilador de Eclipse para Java o en el compilador online de Java.