Add or Update Entries in HashMap in Kotlin | Kotlin HashMap put Function

The put function in Kotlin is used to add a key-value pair to a HashMap or update the value associated with an existing key. This function is part of the Kotlin standard library and provides a convenient way to insert or update entries in a map.

Table of Contents

1. Introduction
2. put Function Syntax
3. Understanding put
4. Examples
   • Basic Usage
   • Updating an Existing Key
   • Adding Multiple Entries
5. Real-World Use Case
6. Conclusion

Introduction

The put function allows you to insert a new key-value pair into a HashMap or update the value for an existing key. If the key already exists in the map, the function updates the associated value. If the key does not exist, the function adds a new entry to the map.

put Function Syntax

The syntax for the put function is as follows:

fun put(key: K, value: V): V?

Parameters:

• key: The key with which the specified value is to be associated.
• value: The value to be associated with the specified key.

Returns:

• V?: The previous value associated with the key, or null if there was no mapping for the key.

Understanding put

The put function either inserts a new key-value pair or updates the value for an existing key in the HashMap. If the key is already present, the function returns the old value associated with the key. If the key is not present, the function returns null.

Examples

Basic Usage

To demonstrate the basic usage of put, we will create a HashMap and add some entries to it.

Example

fun main() {
    val map = hashMapOf<String, Int>()
    map.put("Alice", 30)
    map.put("Bob", 25)
    map.put("Charlie", 35)

    println("Map after adding entries: $map")
}

Output:

Map after adding entries: {Alice=30, Bob=25, Charlie=35}

Updating an Existing Key

This example shows how to use put to update the value for an existing key.

Example

fun main() {
    val map = hashMapOf(
        "Alice" to 30,
        "Bob" to 25,
        "Charlie" to 35
    )
    val oldValue = map.put("Bob", 28)

    println("Map after updating 'Bob': $map")
    println("Old value associated with 'Bob': $oldValue")
}

Output:

Map after updating 'Bob': {Alice=30, Bob=28, Charlie=35}
Old value associated with 'Bob': 25

Adding Multiple Entries

This example demonstrates how to add multiple entries to a HashMap using the put function.

Example

fun main() {
    val map = hashMapOf<String, Int>()
    map.put("Alice", 30)
    map.put("Bob", 25)
    map.put("Charlie", 35)
    map.put("David", 40)

    println("Map after adding multiple entries: $map")
}

Output:

Map after adding multiple entries: {Alice=30, Bob=25, Charlie=35, David=40}

Real-World Use Case

Managing a Map of User Data

In real-world applications, the put function can be used to manage a map of user data, such as storing user information.

Example

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

fun main() {
    val userMap = hashMapOf<Int, User>()

    userMap.put(1, User(1, "Alice", "alice@example.com"))
    userMap.put(2, User(2, "Bob", "bob@example.com"))
    userMap.put(3, User(3, "Charlie", "charlie@example.com"))

    // Update user information
    userMap.put(2, User(2, "Bob", "bob.new@example.com"))

    println("User map: $userMap")
}

Output:

User map: {1=User(id=1, name=Alice, email=alice@example.com), 2=User(id=2, name=Bob, email=bob.new@example.com), 3=User(id=3, name=Charlie, email=charlie@example.com)}

Conclusion

The put function in Kotlin is a powerful and flexible way to insert or update key-value pairs in a HashMap. It allows you to manage and manipulate map entries efficiently, making it useful for various applications, including data management and user information handling. 

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