Método HashMap computeIfAbsent() en Java con ejemplos

El método computeIfAbsent(Key, Function) de la clase HashMap se usa para calcular el valor de una clave dada usando la función de mapeo dada, si la clave aún no está asociada con un valor (o está asignada a nulo) e ingresa ese valor calculado en Hashmap de lo contrario nulo.

Si la función de mapeo de este método devuelve un valor nulo, entonces no se registra ningún mapeo para esa clave.
En el momento del cálculo, 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 la modificación de este mapa utilizando este método.
Este método generará una ConcurrentModificationException si la función de reasignación modificó este mapa durante el cálculo.

Sintaxis:

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

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

clave : clave para la que queremos calcular el valor mediante el mapeo.
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 .

Los siguientes programas ilustran el 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);
    }
}

Producción:

HashMap:
 {key1=10000, key2=55000, key3=44300, key4=53200}
New 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);
    }
}

Producción:

HashMap:
{20=Suraj, 10=Aman, 30=Harsh}
New HashMap:
{20=Suraj, 40=Sanjeet, 10=Aman, 30=Harsh}

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

Publicación traducida automáticamente

Artículo escrito por AmanSingh2210 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta