Metoda HashMap computeIfAbsent() în Java

Java 8, după cum mulți dintre noi știm, a introdus Stream API. Acesta este un set de instrumente foarte util, dar are un dezavantaj, nu include hărți . Cu toate acestea, Java 8 a adăugat mai multe metode utile la interfața Map în sine pentru a reduce cantitatea de cod „prost”. Deci, dacă trebuie să efectuați o acțiune cu valoarea din Map , dacă aceasta există în ea, există o metodă ComputeIfPresent() în Java Map. Dacă trebuie să faceți ceva cu o valoare care nu este în Map , puteți utiliza metoda ComputeIfAbsent() . O vom lua în considerare în acest articol.

semnătura metodei computeIfAbsent().

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

Metoda Map (și HashMap ) computeIfAbsent() ia doi parametri. Primul parametru este cheia. Al doilea parametru este mappingFunction . În această metodă, funcția de mapare este apelată numai dacă maparea nu este prezentată.

Cum funcționează metoda computeIfAbsent().

După cum știm deja, metodei Map.computeIfAbsent() i se trec doi parametri, cheia și funcția pentru calcularea valorii pentru această funcție mapping- cheie . Iată algoritmul logic al metodei:

1. Metoda verifică mai întâi dacă cheia transmisă este reprezentată în harta noastră .
2. Dacă cheia este reprezentată în Map (și nu este nulă), atunci metoda nu face nimic.
3. Altfel, dacă cheia nu reprezintă în Map (sau este nulă), metoda calculează valoarea folosind mappingFunction la cheie.
4. Dacă valoarea rezultată nu este nulă, atunci scrieți o pereche cheie-valoare pe hartă.

Să scriem aceeași logică ca și codul:

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

Exemplu de cod computeIfAbsent().

Deci, dacă valoarea nu este în Hartă , atunci metoda va efectua modificările. Să aruncăm o privire la un exemplu simplu:

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

Ieșirea este: Acum să vedem ce va face metoda când există o valoare dată în Hartă . Alertă spoiler: nu va face nimic.

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

Iată rezultatul: După cum puteți vedea, valoarea rămâne neschimbată.

Încă un exemplu ComputeIfAbsent().

Dacă sunteți familiarizat cu conceptul de cache, metoda computeIfAbsent() probabil vă amintește de ceva. Să aruncăm o privire la un exemplu de parsare mai complex. Să apelăm de două ori metoda computeIfAbsent() pentru a ne asigura că în primul caz valoarea se schimbă, în timp ce în al doilea nu.

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

}

Iată rezultatul: