📌  相关文章
📜  斯卡拉地图

📅  最后修改于: 2022-05-13 01:55:48.284000             🧑  作者: Mango

斯卡拉地图

Map是键值对的集合。换句话说，它类似于字典。键始终是唯一的，而值不必是唯一的。键值对可以具有任何数据类型。但是，曾经用于任何键和值的数据类型必须始终保持一致。 Map 分为两种类型： mutable和immutable 。默认情况下，Scala 使用不可变 Map。为了使用可变映射，我们必须显式导入scala.collection.mutable.Map类。

如何创建 Scala 映射

可以根据我们的要求和地图的性质以不同的方式创建地图。根据 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, ....)


Scala 地图上的操作

我们可以在 Map 上执行三种基本操作：

  1. 键：在 Scala Map 中，此方法返回一个包含映射中每个键的迭代。
  2. values： Value 方法返回一个包含 Scala 映射中每个值的可迭代对象。
  3. isEmpty：如果映射为空，则此 Scala 映射方法返回 true，否则返回 false。


    使用键访问值

    可以使用 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 中不存在这样的键。因此，建议在使用 key 访问任何值时使用contains()函数。
    此函数检查 Map 中的键。如果密钥存在，则返回 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 的情况下，任何键的值所做的任何更改都被接受。
    例子：
    更新不可变地图： 

    // 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)
  
    }
}

    输出：


    更新可变地图： 

    // 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)
    }
}

    输出：

    添加新的键值对

    我们可以使用+=运算符在可变映射中插入新的键值对，然后添加或更新新的对。
    例子： 

    // 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)
    }
}

    输出：

    删除键值对：

    删除键值对类似于添加新条目。不同之处在于我们使用-=运算符而不是+=运算符，后跟要删除的键。
    例子： 

    // 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)
    }
}

    输出：

    地图中的迭代

    键值对对应于具有两个元素的元组。因此，在执行迭代时，循环变量需要是一对。
    要了解 Scala 中循环的语法和工作原理，请参阅：Loops|Scala
    例子： 

    // 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


    空地图

    在 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)