HashMap computeIfAbsent() metódus Java nyelven

A Java 8, amint azt sokan tudjuk, bevezette a Stream API-t. Ez egy nagyon hasznos eszköztár, de van egy hátránya, nem tartalmazza a Map s-t. A Java 8 azonban több hasznos módszert is hozzáadott magához a Map felülethez, hogy csökkentse a "rossz" kódok mennyiségét. Tehát, ha valamilyen műveletet kell végrehajtania a Map értékével , ha az benne van, van egy ComputeIfPresent() metódus a Java Mapben. Ha olyan értékkel kell valamit tennie, amely nem szerepel a Térképben , használhatja a ComputeIfAbsent() metódust. Ebben a cikkben megvizsgáljuk.

computeIfAbsent() metódus aláírás

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

A Map (és a HashMap ) computeIfAbsent() metódus két paramétert vesz igénybe. Az első paraméter a kulcs. A második paraméter a mappingFunction . Ebben a módszerben a leképezési függvény csak akkor kerül meghívásra, ha a leképezés nincs bemutatva.

Hogyan működik a computeIfAbsent() metódus

Mint már tudjuk, a Map.computeIfAbsent() metódus két paramétert ad át, a kulcsot és a függvény értékét ennek a kulcsleképezési függvénynek a kiszámításához . Íme a módszer logikai algoritmusa:

1. A metódus először ellenőrzi, hogy az átadott kulcs szerepel-e a térképünkön .
2. Ha a kulcsot a Map ábrázolja (és nem null), akkor a metódus nem csinál semmit.
3. Ellenkező esetben, ha a kulcs nem képviseli a Map- et (vagy nulla), a metódus a kulcshoz tartozó mappingFunction használatával számítja ki az értéket.
4. Ha a kapott érték nem null, akkor írjon egy kulcs-érték párt a leképezéshez.

Írjuk be ugyanazt a logikát, mint a kódot:

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

computeIfAbsent() kód példa

Tehát, ha az érték nem szerepel a térképen , akkor a metódus végrehajtja a változtatásokat. Nézzünk egy egyszerű példát:

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

A kimenet a következő: Most nézzük meg, mit csinál a metódus, ha van egy adott érték a Térképen . Spoiler figyelmeztetés: Nem fog tenni semmit.

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

Íme a kimenet: Mint látható, az érték változatlan marad.

Még egy ComputeIfAbsent() példa

Ha ismeri a gyorsítótárazás fogalmát, a computeIfAbsent() metódus valószínűleg emlékeztet valamire. Nézzünk egy bonyolultabb elemzési példát. Hívjuk meg kétszer a computeIfAbsent() metódust, hogy megbizonyosodjunk arról, hogy az első esetben az érték változik, míg a másodikban nem.

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

}

Íme a kimenet: