HashMap computeIfAbsent()-methode in Java

Zoals velen van ons weten, introduceerde Java 8 de Stream API. Dit is een erg handige toolkit, maar het heeft een nadeel, het bevat geen Map s. Java 8 heeft echter verschillende handige methoden aan de kaartinterface zelf toegevoegd om de hoeveelheid "slechte" code te verminderen. Dus als u een actie moet uitvoeren met de waarde in de Map , als deze erin bestaat, is er een ComputeIfPresent() -methode in Java Map. Als u iets moet doen met een waarde die niet in Map staat , kunt u de methode ComputeIfAbsent() gebruiken. We zullen het in dit artikel bekijken.

handtekening van de computeIfAbsent()-methode

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

De methode Map (en HashMap ) computeIfAbsent() heeft twee parameters. De eerste parameter is de sleutel. De tweede parameter is de mappingFunction . Bij deze methode wordt de mappingfunctie alleen aangeroepen als de mapping niet wordt gepresenteerd.

Hoe de methode computeIfAbsent() werkt

Zoals we al weten, worden aan de methode Map.computeIfAbsent() twee parameters doorgegeven, de sleutel en de functie voor het berekenen van de waarde voor deze sleutel mappingFunction . Hier is het logische algoritme van de methode:

1. De methode controleert eerst of de doorgegeven sleutel wordt weergegeven in onze kaart .
2. Als de sleutel wordt weergegeven in Map (en deze is niet null), doet de methode niets.
3. Anders, als de sleutel niet wordt weergegeven in Map (of als deze null is), berekent de methode de waarde met behulp van mappingFunction naar de sleutel.
4. Als de resulterende waarde niet null is, schrijft u een sleutel-waardepaar om toe te wijzen.

Laten we dezelfde logica schrijven als code:

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

computeIfAbsent() codevoorbeeld

Dus als de waarde niet in de kaart staat , voert de methode de wijzigingen uit. Laten we een eenvoudig voorbeeld bekijken:

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

De uitvoer is: Laten we nu eens kijken wat de methode zal doen als er een bepaalde waarde in de kaart staat . Spoiler alert: het zal niets doen.

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 is de uitvoer: Zoals u kunt zien, blijft de waarde ongewijzigd.

Nog een voorbeeld van ComputeIfAbsent().

Als u bekend bent met het concept van caching, doet de methode computeIfAbsent() u waarschijnlijk ergens aan denken. Laten we eens kijken naar een complexer parseervoorbeeld. Laten we de methode computeIfAbsent() twee keer aanroepen om ervoor te zorgen dat in het eerste geval de waarde verandert en in het tweede geval niet.

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 is de uitvoer: