Scala Map

Map 是一个键值对的集合。换句话说，它类似于字典。键总是唯一的，而值不需要是唯一的。键值对可以有任何数据类型。然而，一旦用于任何键和值的数据类型必须始终一致。Map分为两种类型：可变的和不可变的。Scala默认使用不可变的Map。为了使用易变的Map，我们必须明确导入 scala.collection.mutable.Map 类。

如何创建Scala Map

根据我们的要求和Map的性质，可以用不同的方式创建Map。我们有不同的语法，这取决于Map是可变的还是不可变的。

语法:

// Immutable
variable = Map(key_1 -> value_1, key_2 -> value_2,
 key_3 -> value_3, ....)

// Mutable
variable = scala.collection.mutable.Map(key_1 -> value_1, 
key_2 -> value_2, key_3 -> value_3, ....)

对ScalaMap的操作

我们可以在Map上进行三种基本操作。

1. keys:在Scala Map中，该方法返回一个包含地图中每个键的迭代器。
2. values: Value方法返回一个包含Scala地图中每个值的迭代器。
3. isEmpty:如果地图是空的，这个Scala地图方法返回真，否则返回假。

使用键来访问值

可以使用Map变量名和键来访问值。

示例:

// Scala map program of 
// Accessing Values Using Keys
  
// Creating object 
object GFG
{
    // Main method
    def main(args:Array[String])
    {
  
        val mapIm = Map("Ajay" -> 30, 
                        "Bhavesh" -> 20,
                        "Charlie" -> 50)
  
        // Accessing score of Ajay
        val ajay = mapIm("Ajay") 
        println(ajay)
    }
} 

输出:

30

如果我们试图访问与键 “John “相关的值，我们会得到一个错误，因为在Map中没有这样的键存在。因此，建议使用contains()函数来访问任何使用键的值。
这个函数检查地图中的键。如果键是存在的，那么它将返回true，否则返回false。

// Scala map program of 
// Accessing Values Using 
// Keys by contains() function
  
// Creating object
object GFG
{
      
    // Main methode
    def main(args:Array[String])
    {
        val mapIm = Map("Ajay" -> 30,
                        "Bhavesh" -> 20,
                        "Charlie" -> 50)
          
        // the key check in the Map
        val ajay = if(mapIm.contains("Ajay"))
                        mapIm("Ajay") else 0
                          
        val john = if(mapIm.contains("John"))
                        mapIm("John") else 0
  
        println("Ajay:" + ajay)
        println("John:" + john)
    }
} 

输出:

Ajay:30 
John:0

更新数值

如果我们试图更新一个不可变的Map的值，Scala会输出一个错误。另一方面，如果是可变的Map，任何键的值的变化都是可以接受的。

示例：

更新不可变的Map：

// Scala map program of 
// Updating the values
// in immutable map
  
// Creating an object
object GFG
{
    // Main method
    def main(args:Array[String])
    {
  
        val mapIm = Map("Ajay" -> 30, 
                        "Bhavesh" -> 20, 
                        "Charlie" -> 50)
              
        println(mapIm)
          
        //Updating
        mapIm("Ajay") = 10 
  
        println(mapIm)
  
    }
}

输出:

error: value update is not a member of scala.collection.immutable.Map[String, Int] 

更新可改变的Map：

// Scala map program of 
// Updating the values
// in mutable map
  
// Creating Object
object GFG
{
      
    // Main method
    def main(args:Array[String])
    {
  
        val mapMut = scala.collection.mutable.Map("Ajay" -> 30,
                                                  "Bhavesh" -> 20, 
                                                  "Charlie" -> 50)
        println("Before Updating: " + mapMut)
  
        // Updating
        mapMut("Ajay") = 10 
  
        println("After Updating: " + mapMut)
    }
}

输出:

Before Updating: Map(Ajay -> 30, Charlie -> 50, Bhavesh -> 20)   
After Updating: Map(Ajay -> 10, Charlie -> 50, Bhavesh -> 20) 

添加新的键值对

我们可以使用+=操作符在一个可变的地图中插入新的键值对，后面是要添加或更新的新键值对。

示例:

// Scala map program of 
// Adding new key-value pair
  
// Creating object
object GFG
{
      
    // Main method
    def main(args:Array[String])
    {
  
        val mapMut = scala.collection.mutable.Map("Ajay" -> 30, 
                                                  "Bhavesh" -> 20,
                                                  "Charlie" -> 50)
  
        println("Before Adding: "+mapMut)
  
        // Adding a new key "Dinesh" and 
        // updating an existing key "Ajay"
        mapMut += ("Ajay" -> 10, "Dinesh" -> 60)
  
        println("After Adding: "+mapMut)
    }
}

输出:

Before Adding: Map(Ajay -> 30, Charlie -> 50, Bhavesh -> 20)   
After Adding: Map(Ajay -> 10, Dinesh -> 60, Charlie -> 50, Bhavesh -> 20) 

删除一个键值对

删除一个键值对与添加一个新条目类似。不同的是，我们使用-=操作符，而不是+=，后面跟的是要删除的键。

示例:

// Scala map program of 
// Deleting new key-value pair
  
// Creating object
object GFG
{
      
    // Main method
    def main(args:Array[String])
    {
  
        val mapMut = scala.collection.mutable.Map("Ajay" -> 30,
                                                  "Bhavesh" -> 20,
                                                  "Charlie" -> 50)
  
        println("Before Deleting: "+mapMut)
  
        // Deleting key-value pairs with
        // keys "Ajay" and "Charlie"
        mapMut -= ("Ajay", "Charlie")
  
        println("After Deleting: " + mapMut)
    }
}

输出:

Before Deleting: Map(Ajay -> 30, Charlie -> 50, Bhavesh -> 20)   
After Deleting: Map(Bhavesh -> 20) 

Map上的迭代

键值对对应的是一个有两个元素的元组。因此，在执行迭代循环时，变量必须是一对。

示例:

// Scala map program of 
// Iteration in a Map
  
// Creating object
object GFG
{
      
    // Main method
    def main(args:Array[String])
    {
  
        val mapMut = scala.collection.mutable.Map("Ajay" -> 30,
                                                  "Bhavesh" -> 20,
                                                  "Charlie" -> 50)
  
        // (k, v) is a tuple with two elements
        for((k, v) <- mapMut) 
        {    
            //where k is key and v is value
            print("Key:"+k+", ")
            println("Value:"+v)
        }
    }
}

输出:

Key:Ajay, Value:30
Key:Charlie, Value:50
Key:Bhavesh, Value:20

**Empty Map **

在Scala Map中，我们也可以创建一个空的Map，然后再向其添加元素。

示例:

// Scala map program of 
// Empty Map
  
// Creating object
object GFG
{
      
    // Main method
    def main(args:Array[String])
    {
  
        // Creation of Map having key-value
        // pairs of type (String, Int)
        val mapMut = scala.collection.mutable.Map[String, Int]()
  
        println("Empty Map: " + mapMut)
  
        // Adding new entry
        mapMut += ("Charlie" -> 50) 
  
         println("New Entry: " + mapMut)
    }
}

输出:

Empty Map: Map()
New Entry: Map(Charlie -> 50)