Map.computeIfAbsent() Method in java with examples

When working with Maps in Java, you’ve likely encountered the frustrating issue of null values.
You try to retrieve a value from a Map, but it does not exists and you get a null value, which mostly results in NullPointerException.
This is where the computeIfAbsent() method comes in – which helps you avoid null pointer exceptions and improve your code’s readability.
In this tutorial, you’ll learn how to use computeIfAbsent() to simplify your Map operations and write more efficient code.

What is computeIfAbsent()?

computeIfAbsent() method was introduced in Java 8 in Map interface.
Syntax for computeIfAbsent() is

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

Here, K represents the type of the key, V represents the type of the value, and Function is a functional interface that takes a key as an argument and returns a value.

computeIfAbsent() takes two arguments:
a key, and
a function.
If the key exists in the Map, computeIfAbsent() returns the associated value.
If the key doesn’t exist, it computes the value using the provided function, stores it in the Map, and returns the computed value.

computeIfAbsent() is a default interface method, meaning that its implementation is defined in java.util.Map interface only.

computeIfAbsent() example

Below is an example to explain how computeIfAbsent() works

Map<String, String> map = new HashMap<>(); 
String value = map.computeIfAbsent("key", k -> "default value");

In this example, if the key “key” is not present in the Map, computeIfAbsent() will compute the value “default value” using the provided function, store it in the Map, and return the computed value.
If the key is already present, computeIfAbsent() will simply return the associated value.

Handling Null Values

In this example, we will see how computeIfAbsent() can be used to handle null values in a Map.

Map<String, String> map = new HashMap<>(); 
map.put("key", null); 
String value = map.computeIfAbsent("key", k -> "default value"); 
System.out.println(value); // prints "default value"

As you can see, even though the key “key” exists in the map with a null value, computeIfAbsent() still computes and stores the default value “default value” and returns it.

Using Method Reference

In this example, we will learn how to use a method reference as the function argument to computeIfAbsent().

Map<String, String> map = new HashMap<>(); 
String value = map.computeIfAbsent("key", String::toUpperCase); 
System.out.println(value); // prints "KEY"

As you can see, the method reference String::toUpperCase is used to compute the value based on the key.

Performance Considerations

When using computeIfAbsent(), you need to consider the function you provide from the point of view of performance.
If the function is computationally expensive or has side effects, you may end up causing performance issues or unintended behavior.
For example, if you use a function that queries a database or performs a network request, you may end up causing a bottleneck in your application.

Another important consideration is thread safety. If you’re using a concurrent map, you need to ensure that the function you provide is thread-safe.
If the function is not thread-safe, you may end up with inconsistent results or even deadlocks.

In terms of performance, computeIfAbsent() can be slower than other map methods like get() or put() because it involves additional overhead, such as creating a new entry in the map if the key is not present.
However, this overhead is usually negligible compared to the benefits of using computeIfAbsent().

Finally, be aware that computeIfAbsent() can lead to memory leaks if you’re not careful.
If you’re using a map with a large number of entries, and you’re using computeIfAbsent() to compute values that are not actually needed, you may end up storing unnecessary values in the map, leading to memory leaks.

Handling Complex Data Structures

Imagine you have a Map that stores information about users, where each user has a name, age, and a list of addresses.
You want to retrieve the first address of a user, but if the user doesn’t exist or doesn’t have any addresses, you want to return a default value.
You can use computeIfAbsent() to achieve this as shown below

Map<String, User> users = new HashMap<>(); 
String defaultAddress = users.
                        computeIfAbsent("John", 
                               k -> new User(k, 25, Arrays.asList("default address"))).
                        getAddresses().
                        get(0);

In this example, if the user “John” doesn’t exist in the Map, computeIfAbsent() will create a new User object with default values and store it in the Map.
Then, it will retrieve the first address from the list of addresses.

Another common scenario is when you need to store a List of objects in a Map, and you want to ensure that the List is initialized if it doesn’t exist.
Below example shows how this can be achieved with computeIfAbsent()

Map<String, List> cache = new HashMap<>(); 
List values = cache.computeIfAbsent("key", k -> new ArrayList<>()); 
values.add("new value");

In this example, if the key “key” doesn’t exist in the Map, `computeIfAbsent` will create a new ArrayList and store it in the Map.
Then, you can add new values to the List.

Errors and Exceptions

You can get exceptions when working with computeIfAbsent().
This section explores those exceptions in detail with examples.

NullPointerException

One of the most common errors you might encounter is a NullPointerException.
This can happen when you try to compute a value using a null key. For example

Map<String, String> map = new HashMap<>(); 
String key = null; 
String value = map.computeIfAbsent(key, k -> "default value");

In this case, you’ll get a NullPointerException because you can’t use a null key in a Map.
To avoid this, make sure to check for null keys before calling computeIfAbsent().

ConcurrentModificationException

Another error you might encounter is a ConcurrentModificationException.
This can happen when you’re using computeIfAbsent() method on a Map that’s being modified concurrently by multiple threads.
To avoid this, use a thread-safe Map implementation, such as ConcurrentHashMap, or synchronize access to the Map.

UnsupportedOperationException

This exception is thrown when you try to use computeIfAbsent() on a Map that does not support this operation.

For example, if you’re working with an unmodifiable Map, such as Collections.unmodifiableMap(), calling computeIfAbsent() will result in an UnsupportedOperationException.
This is because unmodifiable Maps do not allow modifications, and computeIfAbsent() attempts to modify the Map by adding a new entry if the key is not present.

To avoid this exception, make sure you’re working with a Map implementation that supports the computeIfAbsent() method, such as HashMap, LinkedHashMap, or ConcurrentHashMap.

ClassCastException

When you use computeIfAbsent(), you need to make sure that the type of the value returned by the function is compatible with the type of the map’s values.

If the function returns a value of a type that is not compatible with the map’s value type, a ClassCastException will be thrown at runtime.
For example, if you have a Map<String, Integer> and the function returns a String, you’ll get a ClassCastException when trying to store the value in the map.

Here’s an example of how this might happen

Map<String, Integer> map = new HashMap<>(); 
String value = map. 
               computeIfAbsent("key", k -> "default value"); // ClassCastException

Summing up

You now have a comprehensive understanding of the computeIfAbsent() method in Java, including its syntax, benefits, and examples of usage.
You’ve seen how it can help you avoid null pointer exceptions, improve code readability, and reduce boilerplate code.
By applying computeIfAbsent() in your own projects, you’ll be able to write more efficient and robust code, making the most of Java’s Map data structure.