HashMap computeIfAbsent() method sa Java

Ipinakilala ng Java 8, tulad ng alam ng marami sa atin, ang Stream API. Ito ay isang napaka-kapaki-pakinabang na toolkit, ngunit ito ay may isang sagabal, hindi ito kasama ang Map s. Gayunpaman, nagdagdag ang Java 8 ng ilang kapaki-pakinabang na pamamaraan sa interface ng Map mismo upang bawasan ang dami ng "masamang" code. Kaya, kung kailangan mong magsagawa ng ilang aksyon na may value sa Map , kung mayroon ito, mayroong ComputeIfPresent() na paraan sa Java Map. Kung kailangan mong gumawa ng isang bagay na may value na wala sa Map , maaari mong gamitin ang ComputeIfAbsent() method. Isasaalang-alang natin ito sa artikulong ito.

computeIfAbsent() method signature

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

Ang pamamaraan ng Map (at HashMap ) computeIfAbsent() ay tumatagal ng dalawang parameter. Ang unang parameter ay ang susi. Ang pangalawang parameter ay ang mappingFunction . Sa pamamaraang ito ang pag-andar ng pagmamapa ay tinatawag lamang kung ang pagmamapa ay hindi ipinakita.

Paano gumagana ang computeIfAbsent() method

Tulad ng alam na natin, ang Map.computeIfAbsent() na paraan ay ipinapasa ang dalawang parameter, ang susi at ang function para sa pagkalkula ng halaga para sa key mappingFunction na ito . Narito ang lohikal na algorithm ng pamamaraan:

1. Sinusuri muna ng pamamaraan kung ang ipinasa na susi ay kinakatawan sa aming Map .
2. Kung ang susi ay kinakatawan sa Map (at ito ay hindi null), kung gayon ang pamamaraan ay walang ginagawa.
3. Kung hindi man, kung ang key ay hindi kumakatawan sa Map (o ito ay null) ang pamamaraan ay kinakalkula ang halaga gamit ang mappingFunction sa key.
4. Kung ang resultang value ay hindi null, pagkatapos ay magsulat ng key-value pair para imapa.

Isulat natin ang parehong lohika bilang code:

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

computeIfAbsent() halimbawa ng code

Kaya, kung ang halaga ay wala sa Map , gagawin ng pamamaraan ang mga pagbabago. Tingnan natin ang isang simpleng halimbawa:

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

Ang output ay: Ngayon tingnan natin kung ano ang gagawin ng pamamaraan kapag may ibinigay na halaga sa Map . Spoiler alert: Wala itong gagawin.

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

Narito ang output: Tulad ng nakikita mo, ang halaga ay nananatiling hindi nagbabago.

Isa pang halimbawa ng ComputeIfAbsent().

Kung pamilyar ka sa konsepto ng caching, ang computeIfAbsent() na pamamaraan ay malamang na nagpapaalala sa iyo ng isang bagay. Tingnan natin ang isang mas kumplikadong halimbawa ng pag-parse. Tawagan natin ang pamamaraan ng computeIfAbsent() nang dalawang beses upang matiyak na sa unang kaso ay nagbabago ang halaga, habang sa pangalawa ay hindi ito nagbabago.

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

}

Narito ang output: