Scala Map (map)

Scala collections

Map (map) is a kind of iterative key-value pairs (key / value) structure.

All values ​​can be retrieved by a key.

Map the key is unique.

Map is also called a hash table (Hash tables).

Map There are two types of variable and can not be changed, except that the variable object can modify it without mutable objects can not.

By default, Scala immutable Map. If you need to use a variable collection, you need to explicitly introduceimport scala.collection.mutable.Map class

In Scala you can use variable and immutable Map, direct use Map immutable, mutable use mutable.Map. The following example demonstrates the application of immutable Map:

// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()

// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

When you define a Map, you need to define the type of key-value pairs. If you need to add key-value pairs, you can use the + sign, as follows:

A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)

Basic Operations Map

Scala Map There are three basic operations:

Examples

The following example demonstrates the application of the above three basic methods:

object Test {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000",
                       "azure" -> "#F0FFFF",
                       "peru" -> "#CD853F")

      val nums: Map[Int, Int] = Map()

      println( "colors 中的键为 : " + colors.keys )
      println( "colors 中的值为 : " + colors.values )
      println( "检测 colors 是否为空 : " + colors.isEmpty )
      println( "检测 nums 是否为空 : " + nums.isEmpty )
   }
}

Implementation of the above code, the output is:

$ scalac Test.scala 
$ scala Test
colors 中的键为 : Set(red, azure, peru)
colors 中的值为 : MapLike(#FF0000, #F0FFFF, #CD853F)
检测 colors 是否为空 : false
检测 nums 是否为空 : true

Map merger

You can use the++ operator or Map. ++ ()Method to connect two Map, removes duplicate key when Map merger. The following two examples demonstrate the combined Map:

object Test {
   def main(args: Array[String]) {
      val colors1 = Map("red" -> "#FF0000",
                        "azure" -> "#F0FFFF",
                        "peru" -> "#CD853F")
      val colors2 = Map("blue" -> "#0033FF",
                        "yellow" -> "#FFFF00",
                        "red" -> "#FF0000")

      //  ++ 作为运算符
      var colors = colors1 ++ colors2
      println( "colors1 ++ colors2 : " + colors )

      //  ++ 作为方法
      colors = colors1.++(colors2)
      println( "colors1.++(colors2)) : " + colors )

   }
}

Implementation of the above code, the output is:

$ scalac Test.scala 
$ scala Test
colors1 ++ colors2 : Map(blue -> #0033FF, azure -> #F0FFFF, peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)
colors1.++(colors2)) : Map(blue -> #0033FF, azure -> #F0FFFF, peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

Map of output keys and values

The following foreach loop through output Map of keys and values:

object Test {
   def main(args: Array[String]) {
      val sites = Map("w3big" -> "http://www.w3big.com",
                       "baidu" -> "http://www.baidu.com",
                       "taobao" -> "http://www.taobao.com")

      sites.keys.foreach{ i =>  
                           print( "Key = " + i )
                           println(" Value = " + sites(i) )}
   }
}

Implementation of the above code, the output is:

$ scalac Test.scala 
$ scala Test
Key = w3big Value = http://www.w3big.com
Key = baidu Value = http://www.baidu.com
Key = taobao Value = http://www.taobao.com

Check whether the specified Key exists in the Map

You can useMap.contains method to see if the presence of the specified Key Map.Examples are as follows:

object Test {
   def main(args: Array[String]) {
      val sites = Map("w3big" -> "http://www.w3big.com",
                       "baidu" -> "http://www.baidu.com",
                       "taobao" -> "http://www.taobao.com")

      if( sites.contains( "w3big" )){
           println("w3big 键存在，对应的值为 :"  + sites("w3big"))
      }else{
           println("w3big 键不存在")
      }
      if( sites.contains( "baidu" )){
           println("baidu 键存在，对应的值为 :"  + sites("baidu"))
      }else{
           println("baidu 键不存在")
      }
      if( sites.contains( "google" )){
           println("google 键存在，对应的值为 :"  + sites("google"))
      }else{
           println("google 键不存在")
      }
   }
}

Implementation of the above code, the output is:

$ scalac Test.scala 
$ scala Test
w3big 键存在，对应的值为 :http://www.w3big.com
baidu 键存在，对应的值为 :http://www.baidu.com
google 键不存在

Scala Map method

The following table lists the commonly used methods Scala Map:

More ways to refer to the API documentation

Scala collections