O método compute (Key, BiFunction) da classe HashMap permite que você atualize um valor no HashMap. O método compute() tenta calcular um mapeamento para a chave especificada e seu valor mapeado atual (ou nulo se nenhum mapeamento atual for encontrado). Este método é usado para atualizar atomicamente um valor para determinada chave no HashMap.

• Se a função de remapeamento passada em compute retornar nulo, o mapeamento será removido do Map (ou permanecerá ausente se estiver inicialmente ausente).
• Se a função de remapeamento lançar uma exceção, a exceção é lançada novamente e o mapeamento atual permanece inalterado.
• Durante a computação, a função de remapeamento não deve ser capaz de modificar este mapa.
  O método compute() pode ser usado para atualizar um valor existente dentro do HashMap.
  Por exemplo,

  Mapeamento para incrementar um valor interno de mapeamento: map.compute (key, (k, v) -> (v == null)? 1: v + 1)

• A implementação padrão deste método não garante a detecção de um erro se a função de remapeamento do método compute() modificar este mapa durante a computação.

Exceções:
implementações não simultâneas deste método devem substituir este método e lançar uma ConcurrentModificationException se for detectada uma alteração no mapeamento durante a computação. Implementações simultâneas devem substituir esse método e lançar uma IllegalStateException se for detectada uma alteração no mapeamento durante o cálculo e, como resultado, o cálculo nunca será concluído.

A implementação padrão deste método não oferece garantias sobre a sincronização ou propriedades atômicas deste método. Qualquer implementação que forneça garantias de atomicidade deve substituir esse método e documentar suas propriedades de simultaneidade.

Sintaxe:

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

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

• chave : chave com a qual associa o valor.
• remappingFunction : função para calcular o valor.

Retorna: Este método retorna um novo valor associado à chave especificada ou nulo se nenhum .

Exceção: este método gera:

• NullPointerException : se a chave for nula e este mapa não suportar chaves nulas, ou se remappingFunction for nula.
• UnsupportedOperationException : se a operação put não for suportada por este mapa.
• ClassCastException : se a classe da chave ou valor impede que seja armazenado neste mapa.
• IllegalArgumentException : se alguma propriedade da chave ou valor impede que seja armazenado neste mapa.

Os programas abaixo ilustram o método compute (Key, BiFunction):

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);
    }
}

Mapa: {Endereço = Calcutá, Nome = Aman}
Novo mapa: {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);
    }
}

Mapa: {Key2 = 15, Key1 = 12}
Novo mapa: {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);
        }
    }
}

Mapa: {Key2 = 15, Key1 = 12}
Exceção: java.lang.NullPointerException

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