Métodos principales de HashMap en Java

HashMap en Java

HashMap en Java


En esta entrada vamos a ver los métodos principales de HashMap en Java así como algunas de sus funcionalidades desde Java 8 y anterior a Java 8, que podríamos decir que fue uno de los mayores cambios de Java de los últimos años.

¿Qué es un HashMap?

Un HashMap en Java es una tabla hash basado en una implementación de la interfaz Map de Java, el cual será una colección de Key-value (clave-valor).

Un HashMap permite nulos y no se encuentra ordenada.

Obtener un valor de un HashMap por Key

Para obtener un valor de un HashMap por la key podemos hacer uso de la función get(Object key), la cual nos devolverá el valor de esa clave.

Actualizar un HashMap por Key

Para actualizar un HashMap en Java vamos a hacer uso de put. Con put vamos a obtener un valor por su key y sobreescribir encima su valor. En el caso en el que esa key no exista, se creará la key con su valor.

 Map<String, String> map = new HashMap<>();
  map.put("apple", "green");
  System.out.println(map.get("apple"));   // green

Si por ejemplo, tenemos un map con valores integer y queremos incrementar un valor podemos hacer:

Map<String, Integer> map = new HashMap<>();
  // en el caso en el que la key no exista puede lanzar NullPointerException
  map.put("total", map.get("total") + 1);

Para evitar el problema anterior del null pointer en el caso en el que no exista la clave podemos usar containsKey():

Map<String, Integer> map = new HashMap<>();

  for (int i = 0; i < 10; i++) {
      if (map.containsKey("total")) {
          map.put("count", map.get("total") + 1);
      } else {
          map.put("total", 1);
      }
  }

A partir de Java 8 podemos hacer uso de getOrDefault(), para evitar los problemas de null pointer, añadiendo un valor para cuando no exista la clave:

Map<String, Integer> map = new HashMap<>();
map.put("total", map.getOrDefault("total", 0) + 1);

El uso de getOrDefault() es bueno para los casos en los que queramos por ejemplo inicializar un contador.

Eliminar un entrada de un HashMap

Para eliminar una entrada de un HashMap hacemos uso de remove, con la que eliminaremos esa entrada de nuestro mapa:

 Map<String, String> map = new HashMap<>();
 map.put("apple", "green");
 
 map.remove("apple"); 

Saber si existe una entrada en un Map

Como hemos visto en un ejemplo anterior, podemos analizar si existe una key en un Map con containskey(). Containskey() nos devuelve valor false o true si existe la clave.

Map<String, Integer> map = new HashMap<>();

if (map.containsKey("total")) {
  return true;
} else {
  return false;
}

Hacer uso de Merge en un HashMap

Una de las funcionalidades que llego de la mano de Java 8 fue la introducción de Merge. Por lo que Merge() nos va a permitir insertar una key/value específica en el hashmap sino esta presente.

Merge nos va a permitir hacer uso de programación funcional y añadir o reemplazar el valor con el nuevo valor específicado en la función. La función Merge() nos devolverá el valor de la clave asociada.

Merge() permite combinar varios valores asignados para una clave concreta mediante una función.


    public static void main(String[] args)
    {
  
        // create a HashMap and add some values
        HashMap<Integer, String> oldCars= new HashMap<>();
        oldCars.put(1, "MUSTANG"); 
        oldCars.put(2, "MEGANE"); 
        oldCars.put(3, "TOLEDO"); 
  
        HashMap<Integer, String> newCars = new HashMap<>();
        newCars .put(1, "A6");  
        newCars .put(2, "A3");  
        newCars .put(3, "I30");  
  
        // print map details
        System.out.println("OldCars: " + oldCars.toString());
  
        System.out.println("New Cars: " + newCars .toString());

        newCars .forEach((key, value) -> 
           oldCars.merge(key,value,(v1, v2) -> v1.equalsIgnoreCase(v2)
                               ? v1
                               : v1 + ", " + v2));

        System.out.println("Mix new cars with oldCars: " + oldCars);
    }

Salida:

OldCars: {1=MUSTANG, 2=MEGANE, 3=TOLEDO}
New Cars: {1=A6, 2=A3, 3=I30}
Mix new cars with oldCars: {1=MUSTANG, A6, 2=MEGANE, A3, 3=TOLEDO, I30}

Hacer uso de Compute con HashMap

La función compute(Key, BiFunction) de la clase HashMap nos permitirá la actualización de un valor dentro de un HashMap. Se actualizará un valor para una clave dada y su valor actual. El valor será null si la clave no se encuentra.

Por lo general, este método es usado para actualizar un valor para una clave.

 public static void main(String[] args) {
  
        Map<String, String> map = new HashMap<>();
        map.put("Model", "Mustang");
        map.put("Brand", "Ford");
  
        System.out.println("Map: " + map);
  
        map.compute("Model", (key, val) -> val.concat(" Blue"));
        map.compute("Brand", (key, val) -> val.concat(" USA"));
  
        System.out.println("New Map: " + map);
    }

Salida:

Map: {Brand=Ford, Model=Mustang}
New Map: {Brand=Ford USA, Model=Mustang Blue}

ComputeIfPresent con un HashMap

La función computeIfPresent(Key, BiFunction) de la clase HashMap nos va a permitir mapear y actualizar el valor para una clave específica si esa key ya se encuentra asociada con el valor ( en otro caso se actualiza a null).

 public static void main(String[] args)
    {
  
        // Create a HashMap and add some values
        HashMap<String, Integer> count= new HashMap<>();
        count.put("Yellow", 1);
        count.put("Black", 2);
        count.put("Green", 3);
  
        System.out.println("Count before :\n "+ count);
  
        count.computeIfPresent("Red", (key, val) -> val + 100);
  
        System.out.println("Count After :\n " + count);
    }

Salida

Count before :
 {Green=3, Yellow=1, Black=2}
Count After :
 {Green=3, Yellow=1, Black=2}

ComputeIfAbsent

La función computeIfAbsent(Key, Function) de la clase HashMap, es muy parecida a ComputeIfPresent. ComputeIfAbsent se encarga de actualizar un valor para una clave dada, si esa key o clave no está todavía asociada al valor.

        HashMap<String, Integer> prices = new HashMap<>();
        prices.put("Mustang", 10000);
        prices.put("Megane", 55000);
        prices.put("Toledo", 44300);
        prices.put("I30", 53200);
  
        // print map details
        System.out.println("Car prices before update: " + prices.toString());
      
        prices.computeIfAbsent("A6", k -> 2000 + 33000);
        prices.computeIfAbsent("A5", k -> 2000 * 34);

        System.out.println("Car prices after update " + prices);

Salida:

Car prices before update: {Mustang=10000, Megane=55000, Toledo=44300, I30=53200}
Car prices after update: {Mustang=10000, Megane=55000, Toledo=35000, I30=68000, A6=44300, A5=53200}

Métodos en un HashMap

K – Clave del mapa

V – El valor asignado a la clave.

MétodoDescripción
clear()Elimina todas las entradas del mapa.
clone()Devuelve una copia de la instancia. Claves y valores no se clonan
compute(K key, BiFunction<? super K, ? super V,? extends V> remappingFunction)Calcula un valor para la clave especificada y su valor asignado actual.
computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
Si la clave no está asociada con un valor (o el valor es null), intenta calcular su valor utilizando la función pasada por parámetro y añade el valor.
computeIfPresent(K key, BiFunction<? super K, ? super V,? extends V> remappingFunction)
Si el valor de la clave existe y no es null, calcula un nuevo valor con el valor actual.
containsKey(Object key)Devuelve true si existe la clave.
containsValue(Object value)Devuelve true si existe el valor
entrySet()Devuelve una vista de los valores del mapa.
get(Object key)Devuelve el valor para esa key.
isEmpty()Devuelve true si el mapa esta vacío
keySet()Devuelve un conjunto de las claves del mapa.
merge(K key, V value, BiFunction<? super V, ? super V,? extends V> remappingFunction)Si la clave no se encuentra se asocia con el valor que no sea null que se proporciona.
put(K key, V value)Se asocia la clave con el valor.
putAll(Map<? extends K,? extends V> m)Copia todo lo de un mapa en el otro.
remove(Object key)Elimina el elemento proporcionado por la clave.
size()Devuelve el número de elementos Clave/Valor del mapa.
values()Devuelve la colección de valores del mapa.

Conclusión

En esta entranda hemos visto los métodos principales de HashMap en Java. El uso de HashMap() así como sus diferentes métodos nos ayudará en nuestros desarrollos en Java para poder hacer uso de colecciones.

Si necesitas más información puedes escribirnos un comentario o un correo electrónico a refactorizando.web@gmail.com o también nos puedes contactar por nuestras redes sociales Facebook o twitter y te ayudaremos encantados!


Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *