The LinkedHashMap.computeIfAbsent()
method in Java is used to compute a value for a specific key if the key is not already associated with a value (or is mapped to null
).
Table of Contents
- Introduction
computeIfAbsent
Method Syntax- Examples
- Computing Values for Absent Keys
- Handling Existing Keys
- Real-World Use Case
- Example: Initializing Default Values
- Conclusion
Introduction
The LinkedHashMap.computeIfAbsent()
method is a member of the LinkedHashMap
class in Java. It allows you to compute a value for a specific key if the key is not already associated with a value (or is mapped to null
). This method is useful for initializing default values or performing computations only when necessary.
computeIfAbsent() Method Syntax
The syntax for the computeIfAbsent
method is as follows:
public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
- The method takes two parameters:
key
of typeK
, which represents the key whose value is to be computed.mappingFunction
of typeFunction<? super K, ? extends V>
, which represents the function to compute a value.
- The method returns the current (existing or computed) value associated with the specified key, or
null
if the computed value isnull
.
Examples
Computing Values for Absent Keys
The computeIfAbsent
method can be used to compute and insert values for keys that are not already present in the LinkedHashMap
.
Example
import java.util.LinkedHashMap;
import java.util.function.Function;
public class ComputeIfAbsentExample {
public static void main(String[] args) {
// Creating a LinkedHashMap with String keys and Integer values
LinkedHashMap<String, Integer> people = new LinkedHashMap<>();
// Adding some entries to the LinkedHashMap
people.put("Ravi", 25);
people.put("Priya", 30);
// Computing a value for a key that is absent
Integer ageVijay = people.computeIfAbsent("Vijay", new Function<String, Integer>() {
@Override
public Integer apply(String key) {
return 35;
}
});
// Printing the result and the LinkedHashMap after computation
System.out.println("Computed age for Vijay: " + ageVijay);
System.out.println("LinkedHashMap after computation: " + people);
}
}
Output:
Computed age for Vijay: 35
LinkedHashMap after computation: {Ravi=25, Priya=30, Vijay=35}
Using Lambda Expression with computeIfAbsent
You can also use a lambda expression to simplify the code.
Example
import java.util.LinkedHashMap;
public class ComputeIfAbsentLambdaExample {
public static void main(String[] args) {
// Creating a LinkedHashMap with String keys and Integer values
LinkedHashMap<String, Integer> people = new LinkedHashMap<>();
// Adding some entries to the LinkedHashMap
people.put("Ravi", 25);
people.put("Priya", 30);
// Computing a value for a key that is absent using a lambda expression
Integer ageVijay = people.computeIfAbsent("Vijay", key -> 35);
// Printing the result and the LinkedHashMap after computation
System.out.println("Computed age for Vijay: " + ageVijay);
System.out.println("LinkedHashMap after computation: " + people);
}
}
Output:
Computed age for Vijay: 35
LinkedHashMap after computation: {Ravi=25, Priya=30, Vijay=35}
Handling Existing Keys
The computeIfAbsent
method does not modify the value if the key already has an associated value.
Example
import java.util.LinkedHashMap;
public class ExistingKeyExample {
public static void main(String[] args) {
// Creating a LinkedHashMap with String keys and Integer values
LinkedHashMap<String, Integer> people = new LinkedHashMap<>();
// Adding some entries to the LinkedHashMap
people.put("Ravi", 25);
people.put("Priya", 30);
// Attempting to compute a value for an existing key
Integer agePriya = people.computeIfAbsent("Priya", key -> 35);
// Printing the result and the LinkedHashMap after computation
System.out.println("Computed age for Priya: " + agePriya);
System.out.println("LinkedHashMap after computation: " + people);
}
}
Output:
Computed age for Priya: 30
LinkedHashMap after computation: {Ravi=25, Priya=30}
Real-World Use Case
Example: Initializing Default Values
A common real-world use case for LinkedHashMap.computeIfAbsent()
is initializing default values when they are not present in the map. For example, let’s consider a scenario where user preferences are stored, and we need to initialize default preferences for users who do not have any preferences set.
Example
import java.util.LinkedHashMap;
public class InitializeDefaultValues {
public static void main(String[] args) {
// Creating a LinkedHashMap to store user preferences
LinkedHashMap<String, String> userPreferences = new LinkedHashMap<>();
// Adding some user preferences to the LinkedHashMap
userPreferences.put("Ravi", "Dark Theme");
userPreferences.put("Priya", "Light Theme");
// Initializing default preferences for users who do not have preferences set
String vijayPreference = userPreferences.computeIfAbsent("Vijay", key -> "Dark Theme");
// Printing the result and the LinkedHashMap after computation
System.out.println("Preference for Vijay: " + vijayPreference);
System.out.println("User Preferences after computation: " + userPreferences);
}
}
Output:
Preference for Vijay: Dark Theme
User Preferences after computation: {Ravi=Dark Theme, Priya=Light Theme, Vijay=Dark Theme}
In this example, LinkedHashMap.computeIfAbsent()
is used to initialize default preferences for users who do not have any preferences set, demonstrating how to handle absent values effectively.
Conclusion
The LinkedHashMap.computeIfAbsent()
method in Java provides a way to compute a value for a specific key if the key is not already associated with a value (or is mapped to null
). By understanding how to use this method, you can efficiently manage and initialize values in your Java applications, making it a versatile tool for data management.