Método HashMap compute() en Java con ejemplos

El método de computación (clave, bifunción) de la clase HashMap le permite actualizar un valor en HashMap. El método compute() intenta calcular una asignación para la clave especificada y su valor asignado actual (o nulo si no se encuentra ninguna asignación actual). Este método se usa para actualizar automáticamente un valor para una clave dada en HashMap.

• Si la función de reasignación pasada en el cálculo devuelve un valor nulo, la asignación se elimina de Map (o permanece ausente si inicialmente estuvo ausente).
• Si la función de reasignación arroja una excepción, la excepción se vuelve a generar y la asignación actual permanece sin cambios.
• Durante el cálculo, la función de reasignación no debería poder modificar este mapa.
  El método compute() se puede usar para actualizar un valor existente dentro de HashMap.
  Por ejemplo,
  

  Mapeo para incrementar un valor int de mapeo: map.compute(key, (k, v) -> (v == null) ? 1 : v+1)

• La implementación predeterminada de este método no garantiza la detección de un error si la función de reasignación del método compute() modifica este mapa durante el cálculo.

Excepciones:
las implementaciones no simultáneas de este método deben anular este método y generar una ConcurrentModificationException si se detecta un cambio en la asignación durante el cálculo. Las implementaciones simultáneas deberían anular este método y lanzar una IllegalStateException si se detecta un cambio en la asignación durante el cálculo y, como resultado, el cálculo nunca se completaría.

La implementación predeterminada de este método no garantiza la sincronización o las propiedades atómicas de este método. Cualquier implementación que proporcione garantías de atomicidad debe anular este método y documentar sus propiedades de concurrencia.

Sintaxis:

default V 
       compute(K key,
             BiFunction<? super K, ? super V, ? 
                 extends V> remappingFunction)

Parámetros: Este método acepta dos parámetros:

• key : clave con la que asociar el valor.
• remappingFunction : función para calcular el valor.

Devoluciones: este método devuelve un nuevo valor asociado con la clave especificada, o nulo si no hay ninguno .

Excepción: este método arroja:

• NullPointerException : si la clave es nula y este mapa no admite claves nulas, o la función de reasignación es nula.
• UnsupportedOperationException : si la operación de colocación no es compatible con este mapa.
• ClassCastException : si la clase de la clave o valor impide que se almacene en este mapa.
• IllegalArgumentException : si alguna propiedad de la clave o valor impide que se almacene en este mapa.

Los siguientes programas ilustran el método de cálculo (clave, bifunción):

Programa 1:

// Java program to demonstrate
// compute(Key, BiFunction) method.
  
import java.util.*;
  
public class GFG {
  
    // Main method
    public static void main(String[] args)
    {
  
        // Create a Map and add some values
        Map<String, String> map = new HashMap<>();
        map.put("Name", "Aman");
        map.put("Address", "Kolkata");
  
        // Print the map
        System.out.println("Map: " + map);
  
        // remap the values using compute() method
        map.compute("Name", (key, val)
                                -> val.concat(" Singh"));
        map.compute("Address", (key, val)
                                   -> val.concat(" West-Bengal"));
  
        // print new mapping
        System.out.println("New Map: " + map);
    }
}

Map: {Address=Kolkata, Name=Aman}
New Map: {Address=Kolkata West-Bengal, Name=Aman Singh}

Programa 2:

// Java program to demonstrate
// compute(Key, BiFunction) method.
  
import java.util.*;
  
public class GFG {
  
    // Main method
    public static void main(String[] args)
    {
  
        // Create a Map and add some values
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 12);
        map.put("Key2", 15);
  
        // print map details
        System.out.println("Map: " + map);
  
        // remap the values
        // using compute method
        map.compute("Key1", (key, val)
                                -> (val == null)
                                       ? 1
                                       : val + 1);
        map.compute("Key2", (key, val)
                                -> (val == null)
                                       ? 1
                                       : val + 5);
  
        // print new mapping
        System.out.println("New Map: " + map);
    }
}

Map: {Key2=15, Key1=12}
New Map: {Key2=20, Key1=13}

Programa 3: Para mostrar NullPointerException

// Java program to demonstrate Exception thrown by
// compute(Key, BiFunction) method.
  
import java.util.*;
  
public class GFG {
  
    // Main method
    public static void main(String[] args)
    {
  
        // create a Map and add some values
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 12);
        map.put("Key2", 15);
  
        // print map details
        System.out.println("Map: " + map);
  
        try {
  
            // remap the values using compute() method
            // passing null value will throw exception
            map.compute(null, (key, value)
                                  -> value + 3);
            System.out.println("New Map: " + map);
        }
        catch (NullPointerException e) {
  
            System.out.println("Exception: " + e);
        }
    }
}

Map: {Key2=15, Key1=12}
Exception: java.lang.NullPointerException

Referencias: https://docs.oracle.com/javase/10/docs/api/java/util/HashMap.html#compute(K, java.util.function.BiFunction)