HashMap computeIfAbsent() metode i Java

Java 8, som mange af os ved, introducerede Stream API. Dette er et meget nyttigt værktøjssæt, men det har en ulempe, det inkluderer ikke kort . Java 8 tilføjede dog flere nyttige metoder til selve kortgrænsefladen for at reducere mængden af ​​"dårlig" kode. Så hvis du har brug for at udføre en handling med værdien i Map , hvis den findes i den, er der en ComputeIfPresent()- metode i Java Map. Hvis du skal gøre noget med en værdi, der ikke er i Map , kan du bruge ComputeIfAbsent() metoden. Vi vil overveje det i denne artikel.

computeIfAbsent() metodesignatur

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

Map (og HashMap ) computeIfAbsent () metoden tager to parametre. Den første parameter er nøglen. Den anden parameter er mappingFunction . I denne metode kaldes kortlægningsfunktionen kun, hvis kortlægningen ikke er præsenteret.

Hvordan computeIfAbsent()-metoden fungerer

Som vi allerede ved, overføres Map.computeIfAbsent() metoden to parametre, nøglen og funktionen til at beregne værdien for denne nøglemappingFunction . Her er den logiske algoritme for metoden:

1. Metoden kontrollerer først, om den beståede nøgle er repræsenteret i vores kort .
2. Hvis nøglen er repræsenteret i Map (og den ikke er null), gør metoden intet.
3. Ellers hvis nøglen ikke repræsenterer i Map (eller den er null), beregner metoden værdien ved hjælp af mappingFunction til nøglen.
4. Hvis den resulterende værdi ikke er null, skal du skrive et nøgleværdi-par, der skal kortlægges.

Lad os skrive den samme logik som kode:

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

computeIfAbsent() kodeeksempel

Så hvis værdien ikke er i kortet , vil metoden udføre ændringerne. Lad os tage et kig på et simpelt 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"));
       }
}

Udgangen er: Lad os nu se, hvad metoden vil gøre, når der er en given værdi i kortet . Spoiler-alarm: Det vil ikke gøre noget.

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 outputtet: Som du kan se, forbliver værdien uændret.

Endnu et ComputeIfAbsent() eksempel

Hvis du er bekendt med begrebet caching, minder computeIfAbsent()- metoden dig sandsynligvis om noget. Lad os tage et kig på et mere komplekst parsing-eksempel. Lad os kalde computeIfAbsent() -metoden to gange for at sikre, at værdien i det første tilfælde ændres, mens den i det andet ikke 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")));
   }

}

Her er outputtet: