构造映射

不可变的Map[String,Int]

val scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)

可变的映射

 val scores_1 = scala.collection.mutable.Map("Alice" -> 3, "Cindy" -> 8)

如果想从一个空的映射开始

val scores_2 = new scala.collection.mutable.HashMap[String, Int]

在scala中，映射是对偶的集合
->操作符用来创建对偶

 val scores_3 = Map(("Alice", 10), ("Bob", 3), ("Cindy", 8))

-> 操作符看上去比圆括号更易读那么一点

 

 

获取映射的值

 

在scala中，函数和映射之间的相似性尤为明显，因为你将使用（）表示法来查找某个对应的值。

val scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
val bobsScore=scores("Bob")
    print(bobsScore)

 

结果：

3

如果映射并不包含请求中使用的键，则会抛出异常。

要检查映射中是否有某个指定的键，可以用contains方法。

val scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
  val bobsScore = if(scores.contains("Bob")) scores("Bob") else 0
    print(bobsScore)

结果

3

由于这样的组合调用十分普遍，以下是一个快捷写法。

val scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)

    val bobsScore = scores.getOrElse("Bob", 0)

    print(bobsScore)

结果

3

更新映射中的值

不能更新一个不可变的映射

val scores_2 = new scala.collection.mutable.HashMap[String, Int]

    scores_2("Bob") = 10

    scores_2("Fred") = 7

    scores_2 += ("chen" -> 1,"shen" -> 4)

    val bobsScore = scores_2.getOrElse("Bob", 0)

    print(bobsScore)

结果

10

要移除某个键和对应的值，使用-=操作符

 val scores_2 = new scala.collection.mutable.HashMap[String, Int]

    scores_2("Bob") = 10

    scores_2("Fred") = 7

    scores_2 += ("chen" -> 1,"shen" -> 4)

    scores_2 -= "chen"

      print(scores_2.getOrElse("chen", 0))

结果

0

不能更新一个不可变的映射，但众多可以做一些同样有用的操作--获取一个包含所需要的更新的新映射。

val scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
 val newScores = scores + ("shen" -> 2, "long" -> 87)
    print(newScores)

结果：

Map(Bob -> 3, long -> 87, Alice -> 10, shen -> 2, Cindy -> 8)

除了把结果作为新值保存外，也可以更新var变量。

 var scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)

    var newScores = scores + ("shen" -> 2, "long" -> 87)

    print(newScores)

结果：

Map(Bob -> 3, long -> 87, Alice -> 10, shen -> 2, Cindy -> 8)

要从不可变的映射中移除某个键，可以用-操作符。

  var scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)

    scores = scores - "Alice"

    print(scores)

结果

Map(Bob -> 3, Cindy -> 8)

迭代映射

var scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
 for(v <- scores.values){
      print(v+",")
    }

结果：

10,3,8,

获取key

 var scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
for (k <- scores.keySet) {
      print(k + ",")
    }

结果

Alice,Bob,Cindy,

 

已排序的映射

 

 

在操作映射时，你需要选定一个实现，一个哈希表或者一个平衡树。默认情况下，scala给的是哈希表。由于对使用的键没有很好的哈希函数，或者需要顺序地访问所有的键，因此，你可能会想要一个树形映射。

要得到一个不可变的树形映射而不是哈希映射的话。可以用：

val scores = scala.collection.immutable.SortedMap("Alice" -> 10, "Fred" -> 7, "Bob" -> 3, "Cindy" -> 8)

    print(scores)

结果

Map(Alice -> 10, Bob -> 3, Cindy -> 8, Fred -> 7)
val months = scala.collection.mutable.LinkedHashMap("January" -> 1,

      "February" -> 2, "March" -> 3, "April" -> 4, "May" -> 5)

    print(months)

结果

Map(January -> 1, February -> 2, March -> 3, April -> 4, May -> 5)
 

 与java互操作

 

把scala映射传递给预期java映射的方法，提供相反的隐式转换。

import scala.collection.JavaConversions.mapAsJavaMap
import java.awt.font.TextAttribute._
 //scala映射
    val attrs = Map(FAMILY -> "Serif", SIZE -> 12)
    //该方法预期一个java映射
    val font = new java.awt.Font(attrs)
    print(font)

结果

java.awt.Font[family=Serif,name=Serif,style=plain,size=12]