4 映射和元组

构造映射

• 映射是键/值对偶的集合
• 构造映射使用Map(键1->值1,...,键n->值n)，Map((键1,值1),...,(键n,值n))或默认为不可变映射。
• 映射本质上是两个元素的对偶，不过Map的键不能重复，元组的的两个元素的第一个可以重复；如果键重复出现，其值会是最后出现的键对应的值

scala> val haohan=Map("及时雨"->"宋江","玉麒麟"->"卢俊义","智多星"->"吴用")
haohan: scala.collection.immutable.Map[String,String] = Map(及时雨 -> 宋江, 玉麒麟 -> 卢俊义, 智多星 -> 吴用)

scala> val tiangang=Map(("及时雨","宋江"),("玉麒麟","卢俊义"),("智多星","吴用"))
tiangang: scala.collection.immutable.Map[String,String] = Map(及时雨 -> 宋江, 玉麒麟 -> 卢俊义, 智多星 -> 吴用)
// 从数组构造
scala> val aa=Array(("及时雨","宋江"),("玉麒麟","卢俊义"),("及时雨","吴用"))
aa: Array[(String, String)] = Array((及时雨,宋江), (玉麒麟,卢俊义), (及时雨,吴用))
// 将数组作为多个参数
scala> val b=Map(aa: _*)
b: scala.collection.immutable.Map[String,String] = Map(及时雨 -> 吴用, 玉麒麟 -> 卢俊义)

• 可变映射 ，使用scala.collection.mutable.Map

//创建一个空映射
scala> val sanqing=scala.collection.mutable.Map[String,Int]()
sanqing: scala.collection.mutable.Map[String,Int] = Map()
//可变的非空映射
scala> val haohan2=scala.collection.mutable.Map("及时雨"->"宋江","玉麒麟"->"卢俊义","智多星"->"吴用")
haohan2: scala.collection.mutable.Map[String,String] = Map(及时雨 -> 宋江, 玉麒麟 -> 卢俊义, 智多星 -> 吴用)

获取映射的值

• 直接用变量名(键)来取值
• 如果键不存在会报错，可以使用contains方法判断一个键是否存在
• getOrElse方法，返回的类型是两个参数的超类型，像if/else似的

scala> haohan("及时雨")
res7: String = 宋江

scala> haohan("入云龙")
java.util.NoSuchElementException: key not found: 入云龙
  at scala.collection.MapLike$class.default(MapLike.scala:228)
  at scala.collection.AbstractMap.default(Map.scala:59)
  at scala.collection.MapLike$class.apply(MapLike.scala:141)
  at scala.collection.AbstractMap.apply(Map.scala:59)
  ... 32 elided
  
scala> haohan.get("玉麒麟")
res8: Option[String] = Some(卢俊义)

scala> haohan.get("入云龙")
res10: Option[String] = None

scala> haohan.getOrElse("飞天虎","不是好汉")
res11: String = 不是好汉

scala> haohan.getOrElse("智多星","不是好汉")
res12: String = 吴用

scala> haohan.getOrElse("智多星",0)
res16: Any = 吴用
//说是Any，实际上和String的也一样
scala> haohan.getOrElse("智多星",0)==haohan.get("智多星").get
res18: Boolean = true

• 不可变的Map使用默认值，适用于直接获取的时候，使用get获取还是Option对象。
  – withDefaultValue 提供默认值
  – withDefault 提供默认函数

//withDefaultValue
scala> val haohan5=haohan.withDefaultValue("非梁山好汉")
haohan5: scala.collection.immutable.Map[String,String] = Map(及时雨 -> 宋江, 玉麒麟 -> 卢俊义, 智多星 -> 吴用)

scala> haohan5.get("飞天雕")
res25: Option[String] = None

scala> haohan5("飞天雕")
res26: String = 非梁山好汉

scala> haohan5("智多星")
res27: String = 吴用

// withDefault
scala> val haohan6=haohan.withDefault(_+"不是好汉!")  //这里的下划线指输入的键
haohan6: scala.collection.immutable.Map[String,String] = Map(及时雨 -> 宋江, 玉麒麟 -> 卢俊义, 智多星 -> 吴用)

scala> haohan6("飞天豹")
res28: String = 飞天豹不是好汉!

更新映射的值

• 更新已存在的键的值或添加新的键值对：针对可变映射
• 新增或更新值：变量名(键)=值
• 新增多个：变量名+=((键1,值1),...,(键n,值n))

scala> haohan("入云龙")="公孙胜"
<console>:13: error: value update is not a member of scala.collection.immutable.Map[String,String]
       haohan("入云龙")="公孙胜"
       ^
scala> haohan2("入云龙")="公孙胜"

scala> haohan2
res33: scala.collection.mutable.Map[String,String] = Map(及时雨 -> 宋江, 玉麒麟 -> 卢俊义, 入云龙 -> 公孙胜, 智多星 -> 吴用)

scala> haohan2 += ("大刀"->"关胜","豹子头"->"林冲")
res34: haohan2.type = Map(及时雨 -> 宋江, 玉麒麟 -> 卢俊义, 豹子头 -> 林冲, 入云龙 -> 公孙胜, 大刀 -> 关胜, 智多星 -> 吴用)

• 移除映射 使用-=
• 变量名 -= 键，如果减去一个不存在的键那么也不会报错

scala> haohan2 -= "豹子头"
res36: haohan2.type = Map(及时雨 -> 宋江, 玉麒麟 -> 卢俊义, 入云龙 -> 公孙胜, 大刀 -> 关胜, 智多星 -> 吴用)

• 对于不可变映射，不能直接修改其值
• 可以再原映射基础上添加形成一个新的映射，原映射保持不变
• 对于 var的不可变映射，可以用+=或-=的方法更新

scala> var haohan7 = haohan+("大刀"->"关胜","豹子头"->"林冲")
haohan7: scala.collection.immutable.Map[String,String] = Map(及时雨 -> 宋江, 智多星 -> 吴用, 玉麒麟 -> 卢俊义, 豹子头 -> 林冲, 大刀 -> 关胜)

scala> haohan7+=("双鞭"->"呼延灼")

scala> haohan7
res43: scala.collection.immutable.Map[String,String] = Map(及时雨 -> 宋江, 智多星 -> 吴用, 玉麒麟 -> 卢俊义, 豹子头 -> 林冲, 大刀 -> 关胜, 双鞭 -> 呼延灼)

scala> haohan7 -= "豹子头"
scala> haohan7
res45: scala.collection.immutable.Map[String,String] = Map(及时雨 -> 宋江, 智多星 -> 吴用, 玉麒麟 -> 卢俊义, 大刀 -> 关胜, 双鞭 -> 呼延灼)

遍历映射

• for((k,v) <- 映射) {处理k和v}
• 哈哈哈

scala> for((k,v) <- haohan7) println(k+"  "+v)
及时雨  宋江
智多星  吴用
玉麒麟  卢俊义
大刀  关胜
双鞭  呼延灼

//反转映射，形成一个新的
scala> for((k,v) <- haohan7) yield(v,k)
res47: scala.collection.immutable.Map[String,String] = Map(呼延灼 -> 双鞭, 吴用 -> 智多星, 关胜 -> 大刀, 宋江 -> 及时雨, 卢俊义 -> 玉麒麟)

元组

• 元组是不同类型的数的聚集，将几个数放在小括号里就是元组
• 一个元组最多有22个元素

scala> val t = (1,0.4,"SS")
t: (Int, Double, String) = (1,0.4,SS)

scala> t.getClass.getName
res48: String = scala.Tuple3

scala> val t1=(1,)
<console>:1: error: illegal start of simple expression
val t1=(1,)
          ^
scala> val t2=Tuple1(2)
t2: (Int,) = (2,)

• 访问元组的元素，使用变量._数字，从1开始计数。

scala> t._1
res53: Int = 1

scala> t._2
res54: Double = 0.4

scala> t._3
res55: String = SS

拉链操作

• zip方法

scala> val keys=Array("A","B","C")
keys: Array[String] = Array(A, B, C)

scala> val values=Array("a","b","c")
values: Array[String] = Array(a, b, c)

scala> keys.zip(values)
res57: Array[(String, String)] = Array((A,a), (B,b), (C,c))
//转为映射
scala> keys.zip(values).toMap
res58: scala.collection.immutable.Map[String,String] = Map(A -> a, B -> b, C -> c)