metode HashMap computeIfAbsent() di Java

Java 8, seperti yang kita ketahui, memperkenalkan Stream API. Ini adalah toolkit yang sangat berguna, tetapi memiliki kekurangan, tidak termasuk Map s. Namun, Java 8 menambahkan beberapa metode berguna ke antarmuka Peta itu sendiri untuk mengurangi jumlah kode "buruk". Jadi, jika Anda perlu melakukan beberapa tindakan dengan nilai di Map , jika ada di dalamnya, ada metode ComputeIfPresent() di Java Map. Jika Anda perlu melakukan sesuatu dengan nilai yang tidak ada di Map , Anda dapat menggunakan metode ComputeIfAbsent() . Kami akan mempertimbangkannya di artikel ini.

tanda tangan metode computeIfAbsent()

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

Metode Map (dan HashMap ) computeIfAbsent () mengambil dua parameter. Parameter pertama adalah kuncinya. Parameter kedua adalah mappingFunction . Dalam metode ini fungsi pemetaan hanya dipanggil jika pemetaan tidak disajikan.

Cara kerja metode computeIfAbsent()

Seperti yang telah kita ketahui, metode Map.computeIfAbsent() dilewatkan dua parameter, kunci dan fungsi untuk menghitung nilai mappingFunction kunci ini . Berikut adalah algoritma logis dari metode ini:

1. Metode ini pertama-tama memeriksa apakah kunci yang diteruskan terwakili dalam Peta kita .
2. Jika kuncinya direpresentasikan dalam Peta (dan itu bukan nol), maka metode tidak melakukan apa-apa.
3. Jika tidak, jika kunci tidak mewakili Peta (atau nol), metode menghitung nilai menggunakan mappingFunction ke kunci.
4. Jika nilai yang dihasilkan bukan nol, maka tulis pasangan kunci-nilai untuk dipetakan.

Mari tulis logika yang sama dengan kode:

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

contoh kode computeIfAbsent()

Jadi, jika nilainya tidak ada di Map , maka metode akan melakukan perubahan. Mari kita lihat contoh sederhana:

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

Outputnya adalah: Sekarang mari kita lihat apa yang akan dilakukan metode ketika ada nilai yang diberikan di Map . Peringatan spoiler: Itu tidak akan melakukan apa-apa.

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

Inilah hasilnya: Seperti yang Anda lihat, nilainya tetap tidak berubah.

Satu lagi contoh ComputeIfAbsent()

Jika Anda terbiasa dengan konsep caching, metode computeIfAbsent() mungkin mengingatkan Anda pada sesuatu. Mari kita lihat contoh penguraian yang lebih kompleks. Mari kita panggil metode computeIfAbsent() dua kali untuk memastikan bahwa dalam kasus pertama nilainya berubah, sedangkan dalam kasus kedua tidak.

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

}

Inilah hasilnya: