Java ConcurrentHashMap putIfAbsent() Method

The ConcurrentHashMap.putIfAbsent() method in Java is used to insert a key-value pair into a ConcurrentHashMap only if the key is not already present in the map.

Table of Contents

1. Introduction
2. putIfAbsent Method Syntax
3. Examples
   • Adding Entries to a ConcurrentHashMap
   • Handling Existing Keys
4. Real-World Use Case
   • Example: Managing a Student Registration System
5. Conclusion

Introduction

The ConcurrentHashMap.putIfAbsent() method is a member of the ConcurrentHashMap class in Java. It allows you to insert a key-value pair into the map only if the key is not already associated with a value. The ConcurrentHashMap class is part of the java.util.concurrent package, designed for high concurrency and scalability.

putIfAbsent() Method Syntax

The syntax for the putIfAbsent method is as follows:

public V putIfAbsent(K key, V value)

• The method takes two parameters:
  • key of type K, which represents the key to be inserted.
  • value of type V, which represents the value to be associated with the key.
• The method returns the current value associated with the specified key, or null if there was no mapping for the key.

Examples

Adding Entries to a ConcurrentHashMap

The putIfAbsent method can be used to add key-value pairs to a ConcurrentHashMap only if the key is not already present.

Example

import java.util.concurrent.ConcurrentHashMap;

public class PutIfAbsentExample {
    public static void main(String[] args) {
        // Creating a ConcurrentHashMap with String keys and Integer values
        ConcurrentHashMap<String, Integer> people = new ConcurrentHashMap<>();

        // Adding entries to the ConcurrentHashMap
        people.putIfAbsent("Ravi", 25);
        people.putIfAbsent("Priya", 30);
        people.putIfAbsent("Vijay", 35);

        // Printing the ConcurrentHashMap
        System.out.println("ConcurrentHashMap: " + people);
    }
}

Output:

ConcurrentHashMap: {Ravi=25, Priya=30, Vijay=35}

Handling Existing Keys

The putIfAbsent method returns the current value associated with the specified key if the key is already present in the ConcurrentHashMap.

Example

import java.util.concurrent.ConcurrentHashMap;

public class ExistingKeyExample {
    public static void main(String[] args) {
        // Creating a ConcurrentHashMap with String keys and Integer values
        ConcurrentHashMap<String, Integer> people = new ConcurrentHashMap<>();

        // Adding entries to the ConcurrentHashMap
        people.put("Ravi", 25);
        people.put("Priya", 30);

        // Trying to add a new value for an existing key
        Integer existingValue = people.putIfAbsent("Ravi", 40);

        // Printing the results
        System.out.println("Existing value for 'Ravi': " + existingValue);
        System.out.println("ConcurrentHashMap: " + people);
    }
}

Output:

Existing value for 'Ravi': 25
ConcurrentHashMap: {Ravi=25, Priya=30}

Real-World Use Case

Example: Managing a Student Registration System

A common real-world use case for ConcurrentHashMap is managing a student registration system where each student can register only once.

Example

import java.util.concurrent.ConcurrentHashMap;

public class StudentRegistration {
    public static void main(String[] args) {
        // Creating a ConcurrentHashMap to manage student registrations
        ConcurrentHashMap<String, String> studentRegistrations = new ConcurrentHashMap<>();

        // Adding student registrations to the ConcurrentHashMap
        studentRegistrations.putIfAbsent("Ravi", "Registered");
        studentRegistrations.putIfAbsent("Priya", "Registered");
        studentRegistrations.putIfAbsent("Vijay", "Registered");

        // Attempting to register a student who is already registered
        String registrationStatus = studentRegistrations.putIfAbsent("Ravi", "Already Registered");

        // Printing the results
        System.out.println("Registration status for 'Ravi': " + registrationStatus);
        System.out.println("Student Registrations: " + studentRegistrations);
    }
}

Output:

Registration status for 'Ravi': Registered
Student Registrations: {Ravi=Registered, Priya=Registered, Vijay=Registered}

In this example, ConcurrentHashMap is used to manage student registrations, ensuring that each student can register only once using the putIfAbsent method.

Conclusion

The ConcurrentHashMap.putIfAbsent() method in Java provides a way to insert key-value pairs into a ConcurrentHashMap only if the key is not already present, in a thread-safe manner. By understanding how to use this method, you can efficiently manage collections of key-value pairs in your Java applications, especially in concurrent environments. The method allows you to handle conditional insertions, making it a versatile tool for data management in multi-threaded scenarios.