[关闭]
@Arslan6and6 2016-09-04T03:13:37.000000Z 字数 3648 阅读 623

scala学习 第四章 映射和元组

scala学习

4.1构造映射

  1. 不可变映射
  2. scala> val a = Map("al"->10,"bo"->3,"ci"->8)
  3. a: scala.collection.immutable.Map[String,Int] = Map(al -> 10, bo -> 3, ci -> 8)
  4. 可变映射
  5. scala> val b = scala.collection.mutable.Map("al"->10,"bo"->3,"ci"->8)
  6. b: scala.collection.mutable.Map[String,Int] = Map(al -> 10, ci -> 8, bo -> 3)
  7. 新建空映射，需要给定参数类型
  8. scala> val c = new  scala.collection.mutable.HashMap[String, Int]
  9. c: scala.collection.mutable.HashMap[String,Int] = Map()
  11. 映射是对偶的集合，对偶是2个值构成的组，这2个值类型不一定相同
  12. ->操作符创建对偶
  13. scala> "al" -> 10
  14. res12: (String, Int) = (al,10)
  16. 可以种这种方法创建映射
  17. scala> val d = Map(("al",10),("bo",3),("ci",8))
  18. d: scala.collection.immutable.Map[String,Int] = Map(al -> 10, bo -> 3, ci -> 8)

4.2获取映射中的值

  1. 映射名称.("键名称") 查询键对应的值
  2. scala> d("bo")
  3. res14: Int = 3
  5. 查询映射是否包含某个键，并返回键对应的值
  6. scala> val bosScore = if (d.contains("bo")) d("bo") else 0
  7. bosScore: Int = 3
  9. 简洁写法 映射包含某个键就返回键对应的值，否则就返回后面的数字，在此是 0
  10. scala> val bosScore = d.getOrElse("bo", 0)
  11. bosScore: Int = 3
  12. scala> val bosScore = d.getOrElse("x", 0)
  13. bosScore: Int = 0

4.3更新映射中的值

  1. 以上例可变映射 b 为例：
  2. scala> b
  3. res16: scala.collection.mutable.Map[String,Int] = Map(al -> 10, ci -> 8, bo -> 3)
  5. 修改某个键对应的值
  6. scala> b("bo")=6
  7. scala> b
  8. res18: scala.collection.mutable.Map[String,Int] = Map(al -> 10, ci -> 8, bo -> 6)
  10. 新增键值对
  11. scala> b("ec")=17
  12. scala> b
  13. res20: scala.collection.mutable.Map[String,Int] = Map(al -> 10, ci -> 8, ec -> 17, bo -> 6)
  15. 用 += 还可以新增多个键值对
  16. scala> b+=("fs"->9 , ""-> 21)
  17. res21: b.type = Map(fs -> 9, al -> 10, ci -> 8, ec -> 17, "" -> 21, bo -> 6)
  19. 用 -= 删除键值对
  20. scala> b-=("ci", "")
  21. res22: b.type = Map(fs -> 9, al -> 10, ec -> 17, bo -> 6)
  22. scala> b-="al"
  23. res23: b.type = Map(fs -> 9, ec -> 17, bo -> 6)
  25. 不可变映射本身不能被修改，但是可以用 原映射 + 或 - 修改操作 得到一个新的映射 
  26. scala> d
  27. res24: scala.collection.immutable.Map[String,Int] = Map(al -> 10, bo -> 3, ci -> 8)
  28. 修改了 bo 键对应的值，新增了  f -> FC 键值对
  29. scala> val newd = d + ("bo" -> "D" , "f" -> "FC")
  30. newd: scala.collection.immutable.Map[String,Any] = Map(al -> 10, bo -> D, ci -> 8, f -> FC)
  31. 删除键值对 得到新的映射
  32. scala> val newd2 = newd - "ci"
  33. newd2: scala.collection.immutable.Map[String,Any] = Map(al -> 10, bo -> D, f -> FC)
  35. 新老映射共享大部分结构，这样操作效率并不低

4.4迭代映射

"for((k, v) <- 映射) 处理 k 和 v " 

  1. 遍历键值对中的键
  2. scala> for(k <- newd2.keySet) println ("K:" + k)
  3. K:al
  4. K:bo
  5. K:f
  7. 遍历键值对中的值
  8. scala> for (v <- newd2.values) print(v + "\t")
  9. 10  D   FC  
  11. scala> for((k, v) <- newd2)  println ("k:" + k + "\t" + "v:" +v)
  12. k:al    v:10
  13. k:bo    v:D
  14. k:f     v:FC
  16. 分别得到键和值
  17. scala> newd2.keySet
  18. res42: scala.collection.immutable.Set[String] = Set(al, bo, f)
  19. scala> newd2.values 
  20. res40: Iterable[Any] = MapLike(10, D, FC)

4.5已排序映射

  1. 不可变树形映射
  2. scala> val a = scala.collection.immutable.SortedMap("Al" -> 10, "Fr"->7, "Bo"->3, "Ci"->8)
  3. a: scala.collection.immutable.SortedMap[String,Int] = Map(Al -> 10, Bo -> 3, Ci -> 8, Fr -> 7)

4.6与Java互操作

  1. 把Java映射转换为Scala映射
  2. scala> import scala.collection.JavaConversions.mapAsScalaMap
  3. scala> val b:scala.collection.mutable.Map[String,Int]=new java.util.TreeMap[String, Int]
  4. b: scala.collection.mutable.Map[String,Int] = Map()

4.7元组

  1. //元组是不同类型值的聚集
  2. scala> val t = (1, 3.14, "fr")
  3. t: (Int, Double, String) = (1,3.14,fr)
  5. //使用 _1, _2, _3 访问组元 
  6. scala> val t2 = t._2
  7. t2: Double = 3.14
  8. //或是 使用空格而不是 .
  10. //使用模式匹配获取组元
  11. scala> val first = 1;
  12. first: Int = 1
  13. scala> val second = 3.14
  14. second: Double = 3.14
  15. scala> val third = "fr"
  16. third: String = fr
  17. scala> val (first, second, third) = t
  18. first: Int = 1
  19. second: Double = 3.14
  20. third: String = fr
  22. scala> t._2
  23. res3: Double = 3.14
  25. //元组可以用于函数返回不止一个值的情况。举例来说partition返回的是一对字符串，包含了满足某个条件和不满足条件的字符
  26. scala> "New York".partition(_.isUpper)
  27. res9: (String, String) = (NY,ew ork)

4.8拉链操作

使多个元素配对并绑在一起，用zip方法

  1. scala> val c = Array("<", "-",  ">")
  2. c: Array[String] = Array(<, -, >)
  3. scala> val d = Array(2, 10 , 7)
  4. d: Array[Int] = Array(2, 10, 7)
  6. scala> val e = c.zip(d)
  7. e: Array[(String, Int)] = Array((<,2), (-,10), (>,7))
  9. scala> for((s, n ) <- e) print(s*n)
  10. <<---------->>>>>>>
  11. //注意，此处必须是 字符串 s * 整数 n ,调换位置不行
  14. //用 toMap 方法将对偶的集合转换成映射
  15. scala> val keyArray = Array("k1", "k2", "k3")
  16. keyArray: Array[String] = Array(k1, k2, k3)
  18. scala> val valueArray = Array(10, 20, 30)
  19. valueArray: Array[Int] = Array(10, 20, 30)
  21. scala> val pairs = keyArray.zip(valueArray)
  22. pairs: Array[(String, Int)] = Array((k1,10), (k2,20), (k3,30))
  24. scala> val mapping = keyArray.zip(valueArray).toMap
  25. mapping: scala.collection.immutable.Map[String,Int] = Map(k1 -> 10, k2 -> 20, k3 -> 30)
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注