Kotlin mapOfNotNull Function | Create Map Without Null Values in Kotlin

The mapOfNotNull function in Kotlin is used to create a map while filtering out any null values. This function allows you to initialize a map with key-value pairs where null values are excluded, ensuring that the resulting map contains only non-null entries.

Table of Contents

1. Introduction
2. mapOfNotNull Function Syntax
3. Understanding mapOfNotNull
4. Examples
   • Basic Usage
   • Combining Nullable and Non-Nullable Values
   • Creating a Map from a Collection
5. Real-World Use Case
6. Conclusion

Introduction

The mapOfNotNull function is a convenient way to create a map while automatically excluding any null values. This is useful for initializing maps where some values may be null, ensuring that the resulting map contains only non-null entries.

mapOfNotNull Function Syntax

The mapOfNotNull function does not exist directly in the Kotlin standard library, but you can create such functionality using extension functions or standard Kotlin functions combined with filtering.

Example Implementation:

Here's how you can implement a mapOfNotNull function using standard Kotlin functions:'

fun <K, V> mapOfNotNull(vararg pairs: Pair<K, V?>): Map<K, V> {
    return pairs.filter { it.second != null }.map { it.first to it.second!! }.toMap()
}

Understanding mapOfNotNull

The mapOfNotNull function filters out any pairs where the value is null and creates a map containing only the non-null entries. This ensures that the resulting map does not contain any null values, making it safer to use in situations where null values are not desired.

Examples

Basic Usage

To demonstrate the basic usage of mapOfNotNull, we will create a map with some null values.

Example

fun main() {
    val map = mapOfNotNull("a" to 1, "b" to null, "c" to 2)
    println("Map of non-null values: $map")
}

Output:

Map of non-null values: {a=1, c=2}

Combining Nullable and Non-Nullable Values

This example shows how to use mapOfNotNull with a mix of nullable and non-nullable values.

Example

fun main() {
    val key1: String = "Alice"
    val value1: Int? = 25
    val key2: String = "Bob"
    val value2: Int? = null

    val map = mapOfNotNull(key1 to value1, key2 to value2)
    println("Map of non-null values: $map")
}

Output:

Map of non-null values: {Alice=25}

Creating a Map from a Collection

This example demonstrates how to create a map from a collection of pairs that may contain null values.

Example

fun main() {
    val pairs: List<Pair<String, Int?>> = listOf("a" to 1, "b" to null, "c" to 3)
    val map = mapOfNotNull(*pairs.toTypedArray())
    println("Map of non-null values: $map")
}

Output:

Map of non-null values: {a=1, c=3}

Real-World Use Case

Filtering User Input

In real-world applications, the mapOfNotNull function can be used to filter user input or data that may contain null values, ensuring that only valid, non-null data is processed.

Example

fun main() {
    val userInputs: List<Pair<String, String?>> = listOf("username" to "Alice", "email" to null, "phone" to "1234567890")
    val validInputs = mapOfNotNull(*userInputs.toTypedArray())
    println("Map of valid inputs: $validInputs")
}

Output:

Map of valid inputs: {username=Alice, phone=1234567890}

Conclusion

While Kotlin does not provide a built-in mapOfNotNull function, you can easily implement such functionality using standard Kotlin functions. This allows you to create maps that exclude null values, ensuring that the resulting map contains only non-null entries. 

By understanding and using this approach, you can effectively manage maps in your Kotlin applications while avoiding null-related issues.