Kotlin mapOf Function | Create Immutable Maps in Kotlin

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

The mapOf function in Kotlin is used to create a read-only map of key-value pairs. This function belongs to the Kotlin standard library and provides a straightforward way to create maps with predefined elements.

Introduction
mapOf Function Syntax
Understanding mapOf
Examples
- Basic Usage
- Creating a Map with String Keys and Values
- Creating a Map with Mixed Types
Real-World Use Case
Conclusion

Introduction

The mapOf function allows you to create a read-only map containing specified key-value pairs. Maps are collections of key-value pairs where each key is unique, making them useful for storing and retrieving data based on keys.

mapOf Function Syntax

The syntax for the mapOf function is as follows:

fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>

Parameters:

pairs: A variable number of pairs, where each pair consists of a key and a value.

Returns:

A read-only map containing the specified key-value pairs.

Understanding mapOf

The mapOf function creates an immutable map, meaning the key-value pairs in the map cannot be changed after the map is created. This ensures that the map remains read-only and prevents accidental modifications.

Examples

Basic Usage

To demonstrate the basic usage of mapOf, we will create a map of integers.

Example

fun main() {
    val numberMap = mapOf(1 to "One", 2 to "Two", 3 to "Three")
    println("Map of numbers: $numberMap")
}

Output:

Map of numbers: {1=One, 2=Two, 3=Three}

Creating a Map with String Keys and Values

This example shows how to create a map with string keys and values using the mapOf function.

Example

fun main() {
    val countryMap = mapOf("USA" to "Washington, D.C.", "France" to "Paris", "Japan" to "Tokyo")
    println("Map of countries: $countryMap")
}

Output:

Map of countries: {USA=Washington, D.C., France=Paris, Japan=Tokyo}

Creating a Map with Mixed Types

This example demonstrates how to create a map containing elements of different types.

Example

fun main() {
    val mixedMap = mapOf(1 to "One", "Two" to 2, "Three" to 3.0)
    println("Map of mixed types: $mixedMap")
}

Output:

Map of mixed types: {1=One, Two=2, Three=3.0}

Real-World Use Case

Storing Configuration Settings

In real-world applications, the mapOf function can be used to store configuration settings or constant values that should not be modified.

Example

fun main() {
    val config = mapOf("version" to "1.0.0", "appName" to "MyApp", "maxUsers" to 100)
    println("Configuration: $config")
}

Output:

Configuration: {version=1.0.0, appName=MyApp, maxUsers=100}

Conclusion

The mapOf function in Kotlin is a powerful and convenient way to create read-only maps. It allows you to define a collection of key-value pairs, ensuring that the map remains immutable and preventing accidental modifications. This function is useful for various applications, including storing configuration settings, initializing maps, and ensuring data integrity.

By understanding and using the mapOf function, you can effectively manage maps in your Kotlin applications.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide