Kotlin Map : mapOf()

In Kotlin, a Map is a collection that stores data in key-value pairs. Each key in a map is unique, and the map holds only one value for each key. If a key is repeated, only the last value is retained.

Kotlin distinguishes between:

1. Immutable maps (mapOf()) - read-only
2. Mutable maps (mutableMapOf()) - read and write supported

Syntax:

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

• K: Type of keys
• V: Type of values
• Pair<K, V>: Each key-value entry
• Returns a new read-only map

If multiple entries use the same key, only the last value is kept.

Example of mapOf() -

Output:

{1=Geeks, 2=for, 3=Geeks}

Accessing Keys, Values, and Entries -

Output:

Map Entries : {1=One, 2=Two, 3=Three, 4=Four}
Map Keys: [1, 2, 3, 4]
Map Values: [One, Two, Three, Four] 

Map Size -

We can determine the size of map using two methods. By using the size property of the map and by using the count() method. 

Output:

The size of the map is: 4
The size of the map is: 4 

Empty Map -

We can create an empty map using mapOf() with no arguments.

Example -

Output:

Entries: []
Keys:[]
Values:[] 

Getting Values from a Map -

We can retrieve values from a map using different methods discussed in the below program. 

Output:

Team having rank #1 is: India
Team having rank #3 is: England
Team having rank #4 is: Africa
Australia

Map Contains Key or Values -

We can determine that a map contains a key or value using the containsKey() and containsValue() methods respectively. 

Output:

Yes, it contains color yellow
No, it does not contain value 8 

Duplicate Keys Example -

If two values have same key value , then the map will contain the last value of the those numbers.

Example 3: mapOf()

Output:

Entries of map : [1=geeks2, 2=for]

Explanation:

Here key value 1 has been initialized with two values: geeks1 and geeks2, but as we know that mapOf()can have only one value for one key item, therefore the last value is only stored by the map, and geeks1 is eliminated.

Here's an example of using mapOf() to create a map of strings:

Output:

Names: {John=25, Mary=30, Bob=20}
Contains Mary: true

In this example, we create a new read-only map of strings using the mapOf() function with the key-value pairs "John" to 25, "Mary" to 30, and "Bob" to 20. We then retrieve the value associated with the key "John" using the square bracket notation and store it in the variable johnAge. Finally, we check if the map contains the key "Mary" using the containsKey() function and print the result to the console.

Advantages of mapOf():

1. The map data structure provides a way to associate a key with a value, which is useful for organizing and retrieving data.
2. The mapOf() function is easy to use and provides a simple way to create a new read-only map with initial key-value pairs.
3. The read-only nature of the map makes it safe to pass between functions and threads without worrying about concurrent modifications.

Disadvantages of mapOf():

1. The read-only nature of the map means that it cannot be modified once it is created. To add or remove elements, you must create a new map or use a mutable map.
2. The map data structure can become inefficient if the number of key-value pairs is very large, as it requires O(n) time to search for a key in the worst case. If you need to perform frequent lookups or modifications, a different data structure such as a hash table or a binary tree may be more appropriate.