HashMap-computeIfAbsent()-Methode in Java

Wie viele von uns wissen, wurde mit Java 8 die Stream-API eingeführt. Dies ist ein sehr nützliches Toolkit, das jedoch den Nachteil hat, dass es keine Maps enthält . Allerdings hat Java 8 der Map- Schnittstelle selbst mehrere nützliche Methoden hinzugefügt, um die Menge an „schlechtem“ Code zu reduzieren. Wenn Sie also eine Aktion mit dem Wert in der Map ausführen müssen und dieser darin vorhanden ist, gibt es in Java Map eine ComputeIfPresent()- Methode. Wenn Sie etwas mit einem Wert tun müssen, der nicht in Map enthalten ist , können Sie die Methode ComputeIfAbsent() verwenden. Wir werden es in diesem Artikel betrachten.

Signatur der Methode „computeIfAbsent()“.

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

Die Map (und HashMap ) -Methode „computeIfAbsent()“ benötigt zwei Parameter. Der erste Parameter ist der Schlüssel. Der zweite Parameter ist die „mappingFunction“ . Bei dieser Methode wird die Mapping-Funktion nur aufgerufen, wenn das Mapping nicht präsentiert wird.

So funktioniert die Methode „computeIfAbsent()“.

Wie wir bereits wissen, werden der Methode Map.computeIfAbsent() zwei Parameter übergeben, der Schlüssel und die Funktion zur Berechnung des Wertes für diesen Schlüssel . Hier ist der logische Algorithmus der Methode:

1. Die Methode prüft zunächst, ob der übergebene Schlüssel in unserer Map vertreten ist .
2. Wenn der Schlüssel in Map dargestellt wird (und nicht null ist), führt die Methode keine Aktion aus.
3. Andernfalls berechnet die Methode den Wert mithilfe von „mappingFunction“ für den Schlüssel, wenn der Schlüssel nicht in Map dargestellt wird (oder null ist) .
4. Wenn der resultierende Wert nicht null ist, schreiben Sie ein Schlüssel-Wert-Paar für die Zuordnung.

Schreiben wir die gleiche Logik wie den Code:

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

computeIfAbsent()-Codebeispiel

Wenn der Wert also nicht in der Map enthalten ist , führt die Methode die Änderungen durch. Schauen wir uns ein einfaches Beispiel an:

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

Die Ausgabe ist: Sehen wir uns nun an, was die Methode tut, wenn ein bestimmter Wert in Map vorhanden ist . Spoiler-Alarm: Es wird nichts bringen.

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

Hier ist die Ausgabe: Wie Sie sehen, bleibt der Wert unverändert.

Ein weiteres ComputeIfAbsent()-Beispiel

Wenn Sie mit dem Konzept des Cachings vertraut sind, erinnert Sie die Methode „computeIfAbsent()“ wahrscheinlich an etwas. Schauen wir uns ein komplexeres Parsing-Beispiel an. Rufen wir die Methode „computeIfAbsent()“ zweimal auf, um sicherzustellen, dass sich der Wert im ersten Fall ändert, im zweiten Fall jedoch nicht.

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

}

Hier ist die Ausgabe: