O método computeIfAbsent (Key, Function) da classe HashMap é usado para calcular o valor de uma determinada chave usando a função de mapeamento fornecida, se a chave ainda não estiver associada a um valor (ou for mapeada para nulo) e inserir esse valor computado no Hashmap. nulo.

• Se a função de mapeamento desse método retornar nulo, nenhum mapeamento será registrado para essa chave.
• No momento do cálculo, se a função de remapeamento lançar uma exceção, a exceção é relançada e o não mapeamento é registrado.
• Durante o cálculo, a modificação deste mapa usando este método não é permitida.
• Este método lançará uma ConcurrentModificationException se a função de remapeamento modificou este mapa durante o cálculo.

Sintaxe:

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

Parâmetros: este método aceita dois parâmetros:

• chave : chave para a qual queremos calcular o valor usando mapeamento.
• remappingFunction : função para fazer a operação em valor.

Retorna: Este método retorna o valor atual (existente ou calculado) associado à chave especificada ou nulo se o mapeamento retornar nulo .

Os programas abaixo ilustram o método computeIfAbsent (Key, Function):

Programa 1:

// Java program to demonstrate
// computeIfAbsent(Key, Function) method.
  
import java.util.*;
  
public class GFG {
  
    // Main method
    public static void main(String[] args)
    {
  
        // create a HashMap and add some values
        HashMap<String, Integer> map
            = new HashMap<>();
        map.put("key1", 10000);
        map.put("key2", 55000);
        map.put("key3", 44300);
        map.put("key4", 53200);
  
        // print map details
        System.out.println("HashMap:\n "
                           + map.toString());
  
        // provide value for new key which is absent
        // using computeIfAbsent method
        map.computeIfAbsent("key5",
                            k -> 2000 + 33000);
        map.computeIfAbsent("key6",
                            k -> 2000 * 34);
  
        // print new mapping
        System.out.println("New HashMap:\n "
                           + map);
    }
}

HashMap:
 {key1 = 10000, key2 = 55000, key3 = 44300, key4 = 53200}
Novo HashMap:
 {key1 = 10000, key2 = 55000, key5 = 35000, key6 = 68000, key3 = 44300, key4 = 53200}

Programa 2:

// Java program to demonstrate
// computeIfAbsent(Key, Function) method.
  
import java.util.*;
  
public class GFG {
  
    // Main method
    public static void main(String[] args)
    {
  
        // create a HashMap and add some values
        HashMap<Integer, String>
            map = new HashMap<>();
        map.put(10, "Aman");
        map.put(20, "Suraj");
        map.put(30, "Harsh");
  
        // print map details
        System.out.println("HashMap:\n"
                           + map.toString());
  
        // provide value for new key which is absent
        // using computeIfAbsent method
        map.computeIfAbsent(40, k -> "Sanjeet");
  
        // this will not effect anything
        // because key 1 is present
        map.computeIfAbsent(10, k -> "Amarjit");
  
        // print new mapping
        System.out.println("New HashMap:\n" + map);
    }
}

HashMap:
{20 = Suraj, 10 = Aman, 30 = Duro}
Novo HashMap:
{20 = Suraj, 40 = Sanjeet, 10 = Aman, 30 = Duro}

Referências: https://docs.oracle.com/javase/10/docs/api/java/util/HashMap.html#computeIfAbsent(K, java.util.function.Function)