Overview of Scala Maps

Scala Maps are a versatile collection type that stores pairs of keys and values, offering both mutable and immutable options for data management and access.

Key Concepts

• Definition: A Map is a collection of key-value pairs, where each key is unique and associated with a value.
• Types of Maps:
  • Immutable Maps: Once created, the contents of the map cannot be changed.
  • Mutable Maps: Contents can be modified by adding or removing key-value pairs.

Creating Maps

Immutable Maps

You can create an immutable map using the Map class:

val immutableMap = Map("A" -> 1, "B" -> 2, "C" -> 3)

Mutable Maps

To create a mutable map, utilize scala.collection.mutable.Map:

import scala.collection.mutable
val mutableMap = mutable.Map("A" -> 1, "B" -> 2)

Accessing Values

Values in a map can be accessed using their keys:

val value = immutableMap("A")  // Returns 1

If the key does not exist, an exception will be thrown in immutable maps. For mutable maps, you can safely access values with the get method:

val valueOption = mutableMap.get("C")  // Returns None if key doesn't exist

Adding and Updating Values

Immutable Maps

Since immutable maps cannot be changed, you create a new map with the desired changes:

val updatedMap = immutableMap + ("D" -> 4)  // Adds a new key-value pair

Mutable Maps

You can add or update values directly:

mutableMap("C") = 3  // Adds new key-value pair
mutableMap("A") = 10 // Updates existing key

Removing Key-Value Pairs

From Immutable Maps

To remove a key from an immutable map, create a new map:

val reducedMap = immutableMap - "B"  // Removes key "B"

From Mutable Maps

You can remove a key directly:

mutableMap -= "A"  // Removes key "A"

Iterating Over Maps

You can iterate over the elements of a map using a for loop:

for ((key, value) <- immutableMap) {
  println(s"Key: $key, Value: $value")
}

Summary

• Scala Maps consist of key-value pairs.
• They can be mutable or immutable.
• Creating, accessing, modifying, and iterating over maps is straightforward.

Understanding how to effectively use maps is crucial for programming in Scala, making data manipulation both intuitive and efficient.