Método ConcurrentHashMap computeIfAbsent() en Java con ejemplos

El método computeIfAbsent(Key, Function) de la clase ConcurrentHashMap que intenta calcular su valor usando la función de mapeo dada para la clave especificada si la clave no está ya asociada con un valor (o está asignada a nulo) e ingresa ese valor calculado en el mapa si no es nulo .
 

• Si la función de mapeo de este método devuelve un valor nulo, entonces no se registra ningún valor para la nueva clave en el mapa.
• Este método se usa para actualizar atómicamente un valor para una clave determinada en ConcurrentHashMap.
• Si la función de reasignación arroja una excepción, la excepción se vuelve a generar y se registra la ausencia de asignación.
• Durante el cálculo, no se permite modificar este mapa con este método porque otros subprocesos también pueden usar este mapa.

Sintaxis: 
 

public V 
       computeIfAbsent(K key,
             Function<? super K, ? extends V> remappingFunction)

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

• key : clave con la que se va a asociar el valor.
• remappingFunction : función para realizar la operación sobre el valor.

Devoluciones: este método devuelve el valor actual (existente o calculado) asociado con la clave especificada, o nulo si la asignación devuelve nulo .
Excepción: este método arroja:

• NullPointerException: si la clave especificada o función de reasignación es nula.
• IlegalStateException: si el cálculo intenta realizar una actualización recursiva de este mapa que, de otro modo, nunca se completaría.
• RuntimeException: si la función de reasignación lo hace, en cuyo caso la asignación no cambia.

Los siguientes programas ilustran el método de computación si está ausente (clave, función):
Programa 1: 
 

// Java program to demonstrate
// computeIfAbsent(Key, Function) method.
 
import java.util.concurrent.*;
 
public class GFG {
 
    // Main method
    public static void main(String[] args)
    {
 
        // create a ConcurrentHashMap and
        // add some values
        ConcurrentHashMap<String, Integer> map
            = new ConcurrentHashMap<>();
        map.put("Pencil", 1000);
        map.put("Laptop", 55000);
        map.put("Clothes", 4400);
        map.put("Mobile", 5300);
 
        // print map details
        System.out.println("ConcurrentHashMap :\n "
                           + map.toString());
 
        // provide value for new key which is absent
        // using computeIfAbsent method
        map.computeIfAbsent("PC", k -> 60000);
        map.computeIfAbsent("Charger", k -> 800);
 
        // print new mapping
        System.out.println("new ConcurrentHashMap :\n "
                           + map);
    }
}

ConcurrentHashMap :
 {Laptop=55000, Clothes=4400, Pencil=1000, Mobile=5300}
new ConcurrentHashMap :
 {Laptop=55000, PC=60000, Clothes=4400, Pencil=1000, Charger=800, Mobile=5300}

Programa 2: 
 

// Java program to demonstrate
// computeIfAbsent(Key, Function) method.
 
import java.util.concurrent.*;
 
public class GFG {
 
    // Main method
    public static void main(String[] args)
    {
 
        // create a ConcurrentHashMap and
        // add some values
        ConcurrentHashMap<Integer, String> map
            = new ConcurrentHashMap<>();
        map.put(1, "1000RS");
        map.put(2, "5009RS");
        map.put(3, "1300RS");
 
        // print map details
        System.out.println("ConcurrentHashMap : \n"
                           + map.toString());
 
        // provide value for new key which is absent
        // using computeIfAbsent method
        map.computeIfAbsent(4, k -> "6000RS");
 
        // this will not effect anything
        // because key 1 is present
        map.computeIfAbsent(1, k -> "8000RS");
 
        // print new mapping
        System.out.println("new ConcurrentHashMap :\n"
                           + map);
    }
}

ConcurrentHashMap : 
{1=1000RS, 2=5009RS, 3=1300RS}
new ConcurrentHashMap :
{1=1000RS, 2=5009RS, 3=1300RS, 4=6000RS}

Programa 3: Para mostrar NullPointerException
 

// Java program to demonstrate NullPointerException of
// computeIfAbsent(Key, Function) method.
 
import java.util.concurrent.*;
 
public class GFG {
 
    // Main method
    public static void main(String[] args)
    {
 
        // create a ConcurrentHashMap and
        // add some values
        ConcurrentHashMap<String, Integer> map
            = new ConcurrentHashMap<>();
        map.put("Pencil", 1000);
        map.put("Laptop", 55000);
        map.put("Clothes", 4400);
        map.put("Mobile", 5300);
 
        try {
 
            // provide value for new key which is absent
            // using computeIfAbsent method
            map.computeIfAbsent(null, k -> 60000);
        }
        catch (Exception e) {
 
            // print new mapping
            System.out.println("Exception: "
                               + e);
        }
    }
}

Exception: java.lang.NullPointerException

Referencias: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ConcurrentHashMap.html#computeIfAbsent-K-java.util.function.Function-