Check for Key in HashMap in Kotlin | Kotlin HashMap containsKey Function

The containsKey function in Kotlin is used to check if a specified key is present in a HashMap. This function is part of the Kotlin standard library and provides a convenient way to verify the existence of a key in a map.

Table of Contents

1. Introduction
2. containsKey Function Syntax
3. Understanding containsKey
4. Examples
   • Basic Usage
   • Checking for Different Key Types
5. Real-World Use Case
6. Conclusion

Introduction

The containsKey function allows you to check if a specified key is present in a HashMap. This is useful for scenarios where you need to verify the presence of a key before performing operations based on that key.

containsKey Function Syntax

The syntax for the containsKey function is as follows:

fun containsKey(key: K): Boolean

Parameters:

• key: The key to be checked for presence in the map.

Returns:

• Boolean: Returns true if the specified key is present in the map, false otherwise.

Understanding containsKey

The containsKey function checks if the specified key is present in the HashMap by comparing the key with the keys in the map. If a match is found, it returns true; otherwise, it returns false.

Examples

Basic Usage

To demonstrate the basic usage of containsKey, we will create a HashMap and check if specific keys are present in the map.

Example

fun main() {
    val map = hashMapOf(
        "Alice" to 30,
        "Bob" to 25,
        "Charlie" to 35
    )
    println("Does the map contain 'Alice'? ${map.containsKey("Alice")}")
    println("Does the map contain 'David'? ${map.containsKey("David")}")
}

Output:

Does the map contain 'Alice'? true
Does the map contain 'David'? false

Checking for Different Key Types

This example shows how to use containsKey to check for the presence of different types of keys in a HashMap.

Example

fun main() {
    val map = hashMapOf(
        1 to "One",
        2 to "Two",
        3 to "Three"
    )
    println("Does the map contain key 2? ${map.containsKey(2)}")
    println("Does the map contain key 4? ${map.containsKey(4)}")
}

Output:

Does the map contain key 2? true
Does the map contain key 4? false

Real-World Use Case

Checking User Permissions

In real-world applications, the containsKey function can be used to check if a user has specific permissions or roles in a HashMap.

Example

data class User(val id: Int, val name: String)

fun main() {
    val userPermissions = hashMapOf(
        User(1, "Alice") to "Admin",
        User(2, "Bob") to "Editor",
        User(3, "Charlie") to "Viewer"
    )

    val userToCheck = User(2, "Bob")
    if (userPermissions.containsKey(userToCheck)) {
        println("${userToCheck.name} has the role: ${userPermissions[userToCheck]}")
    } else {
        println("${userToCheck.name} does not have any role.")
    }
}

Output:

Bob has the role: Editor

Conclusion

The containsKey function in Kotlin is a simple and effective way to check if a specified key is present in a HashMap. It allows you to verify the presence of keys, making it useful for various applications, including data validation, user permissions, and more. 

By understanding and using the containsKey function, you can effectively manage and manipulate HashMap collections in your Kotlin applications.