HashMap computeIfAbsent()-metoden i Java

Java 8, som mange av oss vet, introduserte Stream API. Dette er et veldig nyttig verktøysett, men det har en ulempe, det inkluderer ikke kart . Java 8 la imidlertid til flere nyttige metoder til selve kartgrensesnittet for å redusere mengden "dårlig" kode. Så hvis du trenger å utføre en handling med verdien i kartet , hvis den finnes i den, er det en ComputeIfPresent()- metode i Java Map. Hvis du trenger å gjøre noe med en verdi som ikke er i Map , kan du bruke ComputeIfAbsent()- metoden. Vi vil vurdere det i denne artikkelen.

computeIfAbsent() metodesignatur

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

Map (og HashMap ) computeIfAbsent () -metoden tar to parametere. Den første parameteren er nøkkelen. Den andre parameteren er mappingFunction . I denne metoden kalles kartfunksjonen bare hvis kartleggingen ikke er presentert.

Hvordan computeIfAbsent()-metoden fungerer

Som vi allerede vet, overføres Map.computeIfAbsent() -metoden to parametere, nøkkelen og funksjonen for å beregne verdien for denne nøkkelmappingFunction . Her er den logiske algoritmen for metoden:

1. Metoden sjekker først om den beståtte nøkkelen er representert i kartet vårt .
2. Hvis nøkkelen er representert i Map (og den ikke er null), gjør metoden ingenting.
3. Ellers hvis nøkkelen ikke representerer i Map (eller den er null), beregner metoden verdien ved å bruke mappingFunction til nøkkelen.
4. Hvis den resulterende verdien ikke er null, skriver du et nøkkelverdi-par som skal kartlegges.

La oss skrive samme logikk som kode:

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

computeIfAbsent() kodeeksempel

Så hvis verdien ikke er i kartet , vil metoden utføre endringene. La oss ta en titt på et enkelt eksempel:

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

Utgangen er: La oss nå se hva metoden vil gjøre når det er en gitt verdi i kartet . Spoilervarsel: Det vil ikke gjøre noe.

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

Her er utgangen: Som du kan se, forblir verdien uendret.

Et annet ComputeIfAbsent() eksempel

Hvis du er kjent med konseptet caching, minner computeIfAbsent()- metoden deg sannsynligvis om noe. La oss ta en titt på et mer komplekst analyseeksempel. La oss kalle computeIfAbsent() -metoden to ganger for å sikre at i det første tilfellet endres verdien, mens den i det andre ikke gjø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")));
   }

}

Her er utgangen: