Java IdentityHashMap size() Method

The IdentityHashMap.size() method in Java returns the number of key-value mappings contained in the map. This guide will cover the method's usage, explain how it works, and provide examples to demonstrate its functionality. We will also cover a real-world use case to show how IdentityHashMap.size() can be used effectively.

Table of Contents

1. Introduction
2. size Method Syntax
3. Examples
   • Basic Usage of size Method
   • After Adding and Removing Elements
4. Real-World Use Case
   • Example: Tracking Active User Sessions
5. Conclusion

Introduction

The IdentityHashMap.size() method is a member of the IdentityHashMap class in Java. This class uses reference equality (==) instead of object equality (equals()) when comparing keys. The size method returns the number of key-value mappings contained in the map.

size() Method Syntax

The syntax for the size method is as follows:

public int size()

• Parameters: This method does not take any parameters.
• Returns: The number of key-value mappings in this map.

Examples

Basic Usage of size Method

The size method can be used to get the number of key-value mappings in the IdentityHashMap.

Example

import java.util.IdentityHashMap;

public class IdentityHashMapSizeExample {
    public static void main(String[] args) {
        // Creating an IdentityHashMap
        IdentityHashMap<String, Integer> map = new IdentityHashMap<>();

        // Adding key-value pairs to the IdentityHashMap
        map.put("Ravi", 25);
        map.put("Priya", 30);
        map.put("Vijay", 35);

        // Getting the size of the IdentityHashMap
        int size = map.size();

        // Printing the size
        System.out.println("IdentityHashMap size: " + size);
    }
}

Output:

IdentityHashMap size: 3

After Adding and Removing Elements

The size method can be used to track the number of key-value mappings after adding and removing elements.

Example

import java.util.IdentityHashMap;

public class IdentityHashMapSizeAddRemoveExample {
    public static void main(String[] args) {
        // Creating an IdentityHashMap
        IdentityHashMap<String, Integer> map = new IdentityHashMap<>();

        // Adding key-value pairs to the IdentityHashMap
        map.put("Ravi", 25);
        map.put("Priya", 30);

        // Getting the size after additions
        int sizeAfterAdditions = map.size();
        System.out.println("Size after additions: " + sizeAfterAdditions);

        // Removing a key-value pair
        map.remove("Ravi");

        // Getting the size after removal
        int sizeAfterRemoval = map.size();
        System.out.println("Size after removal: " + sizeAfterRemoval);
    }
}

Output:

Size after additions: 2
Size after removal: 1

Real-World Use Case

Example: Tracking Active User Sessions

A common real-world use case for IdentityHashMap.size() is tracking the number of active user sessions in a web application where reference equality is required.

Example

import java.util.IdentityHashMap;

public class ActiveUserSessionTracker {
    static class UserSession {
        private String sessionId;
        private String userName;

        public UserSession(String sessionId, String userName) {
            this.sessionId = sessionId;
            this.userName = userName;
        }

        @Override
        public String toString() {
            return "UserSession{" +
                    "sessionId='" + sessionId + '\'' +
                    ", userName='" + userName + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {
        // Creating user sessions
        UserSession session1 = new UserSession("S1", "Ravi");
        UserSession session2 = new UserSession("S2", "Priya");

        // Creating an IdentityHashMap to manage user sessions
        IdentityHashMap<UserSession, String> sessionMap = new IdentityHashMap<>();
        sessionMap.put(session1, "Active");
        sessionMap.put(session2, "Inactive");

        // Getting the number of active user sessions
        int activeSessions = sessionMap.size();

        // Printing the number of active user sessions
        System.out.println("Number of active user sessions: " + activeSessions);

        // Adding a new user session
        UserSession session3 = new UserSession("S3", "Vijay");
        sessionMap.put(session3, "Active");

        // Getting the updated number of active user sessions
        int updatedActiveSessions = sessionMap.size();
        System.out.println("Updated number of active user sessions: " + updatedActiveSessions);
    }
}

Output:

Number of active user sessions: 2
Updated number of active user sessions: 3

In this example, IdentityHashMap.size() is used to track the number of active user sessions, where sessions are identified by reference equality, making it suitable for scenarios where unique object references are crucial.

Conclusion

The IdentityHashMap.size() method in Java provides a way to get the number of key-value mappings contained in the map, using reference equality for key comparison. By understanding how to use this method, you can efficiently manage collections of key-value pairs where reference equality is required. This method allows you to utilize the power of IdentityHashMap for various scenarios, making it a versatile tool for managing collections of key-value pairs based on reference equality.