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, ....)

Scala Map上的操作

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

keys：在Scala Map中, 此方法返回包含map中每个键的Iterable。

values：Value方法返回一个可迭代的值, 其中包含Scala映射中的每个值。

isEmpty：如果Map为空, 则此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中不存在此类键。因此, 建议使用

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

输出如下：

更新前：Map(Ajay-> 30, Charlie-> 50, Bhavesh-> 20)更新后：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)
     }
}

输出如下：

添加之前：Map(Ajay-> 30, 查理-> 50, Bhavesh-> 20)添加之后：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)
     }
}

输出如下：

删除前：Map(阿贾伊-> 30, 查理-> 50, Bhavesh-> 20)删除后：Map(Bhavesh-> 20)

Map中的迭代

键值对对应具有两个元素的元组。因此, 在执行迭代时, 循环变量需要成对。

要了解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

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

---