HashMap computeIfAbsent()-metoden i Java

Java 8, som många av oss vet, introducerade Stream API. Detta är en mycket användbar verktygslåda, men den har en nackdel, den innehåller inte kartor . Java 8 lade dock till flera användbara metoder till själva kartgränssnittet för att minska mängden "dålig" kod. Så om du behöver utföra någon åtgärd med värdet i kartan, om det finns i det, finns det en ComputeIfPresent()- metod i Java Map. Om du behöver göra något med ett värde som inte finns i Map , kan du använda metoden ComputeIfAbsent() . Vi kommer att överväga det i den här artikeln.

computeIfAbsent() metodsignatur

default V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)

Metoden Map ( och HashMap ) computeIfAbsent() tar två parametrar. Den första parametern är nyckeln. Den andra parametern är mappingFunction . I denna metod anropas mappningsfunktionen endast om mappningen inte presenteras.

Hur metoden computeIfAbsent() fungerar

Som vi redan vet skickas Map.computeIfAbsent() -metoden två parametrar, nyckeln och funktionen för att beräkna värdet för denna nyckelmappingFunction . Här är den logiska algoritmen för metoden:

1. Metoden kontrollerar först om den godkända nyckeln finns representerad i vår karta .
2. Om nyckeln är representerad i Map (och den inte är null), gör metoden ingenting.
3. Annars om nyckeln inte representerar i Map (eller den är null) beräknar metoden värdet med hjälp av mappingFunction till nyckeln.
4. Om det resulterande värdet inte är null, skriv sedan ett nyckel-värdepar att mappa.

Låt oss skriva samma logik som kod:

if (map.get(key) == null) 
{ 
V newValue = mappingFunction.apply(key); 
if (newValue != null) map.put(key, newValue); 
}

computeIfAbsent()-kodexempel

Så om värdet inte finns i kartan kommer metoden att utföra ändringarna. Låt oss ta en titt på ett enkelt exempel:

import java.util.HashMap;
import java.util.Map;

//map.computeIfAbsent example 
public class ComputeIfAbsentExample {

       public static void main(String[] args) {

           Map<String, String> myMap = new HashMap<>();

           myMap.computeIfAbsent("here is my key", key -> key + ", " + "and this is a new value");

           System.out.println(myMap.get("here is my key"));
       }
}

Utgången är: Låt oss nu se vad metoden kommer att göra när det finns ett givet värde i kartan . Spoiler alert: Det kommer inte att göra någonting.

import java.util.HashMap;
import java.util.Map;

public class ComputeIfAbsentExample2 {

       public static void main(String[] args) {

           Map<String, String> myMap = new HashMap<>();
           myMap.put("here is my key", "and here is my value");

           myMap.computeIfAbsent("here is my key", key -> key + ", " + "and this is a new value");

           System.out.println(myMap.get("here is my key"));
       }
}

Här är utgången: Som du kan se förblir värdet oförändrat.

Ytterligare ett ComputeIfAbsent() exempel

Om du är bekant med konceptet cachning påminner metoden computeIfAbsent() dig förmodligen om något. Låt oss ta en titt på ett mer komplext analysexempel. Låt oss anropa metoden computeIfAbsent() två gånger för att se till att i det första fallet ändras värdet, medan det i det andra inte gör det.

import java.util.HashMap;
import java.util.Map;

public class ComputeIfAbsentExample {
   private static Map<String, Long> numbersMap = new HashMap<>();

   public static Long stringToLong(String str) {
       return numbersMap.computeIfAbsent(str, key -> {
           System.out.println("parsing: " + key);
           return Long.parseLong(key);
       });
   }

   public static void main(String[] args) {
       // will print:
       // > parsing: 10
       // > parsing: 25
       // > 10+25=35
       System.out.println("10+25=" + (stringToLong("10") + stringToLong("25")));
       // will print:
       // > parsing: 20
       // > 10+25=45
       // only "20" will be parsed this time, since "25" was already parsed and placed into `numbersMap` map before
       System.out.println("20+25=" + (stringToLong("20") + stringToLong("25")));
       // will print:
       // > 10+20=30
       // no parsing will occur, since both "10" and "20" were already parsed and placed into `numbersMap` map before
       System.out.println("10+20=" + (stringToLong("10") + stringToLong("20")));
   }

}

Här är utgången: