Scala语言笔记 - 第二篇

​ 最近研究了下scala语言，这个语言最强大的就是它强大的函数式编程（Function Programming）能力，记录下最近学习的一些新的和技巧。注意：本系列博客不会从头讲解该语言的语法，而是通过一些例子讲解该语言的一些技巧，如果需要从头学习scala，建议使用该教程快速入门。

1 Map的基础操作

​ Map的初始化和添加元素操作，如果直接用Map来生成一个对象，那么默认生成的一个不可变对象map，因此，clear等对原有对象进行更改的方法都是不可用的。

   /**
    * map的基础操作
    */
  def basicMapOp(): Unit = {
    var m:Map[String,String] = Map("key" -> "value")
    //m("key1") = "value2" // 不支持这种用法
    //增加一个键值对
    m += ("key1" -> "value1")
    println(m)
    //如果不存在该键，那么选取默认值
    var value = m.getOrElse("key2","defaultValue")
    println(s"defaultValue:$value")

    //对原来的值进行更改
    m += ("key1" -> "newValue1")
    //合并两个集合
    m ++= List("key2" -> "value2", "key3" -> "value3")
    //合并的时候，如果存在相同的键（key1），那么会被右边的集合给覆盖掉
    m ++= Map("key4" -> "value4", "key5" -> "value5", "key1" -> "valueFromNewMap")
    println(m.get("key1"))
    //删除一个元素
    m -= "key1"

    var hashMap = mutable.HashMap("hello" -> "world")
    hashMap += ("one" -> "two")
    println("this is a hashmap! we will clear it!")
    hashMap.clear()

    //注意，这里是不支持的，默认使用Map构造的是个Immutable，所以没有clear方法。
    //m.clear

    //判断是否为空
    if (hashMap.isEmpty) {
      println("map is empty!")
    }
    else{
      println("map is not empty!")
    }
  }

2 Map生成view和transform解析

​ Map的mapValues方法会生成一个view，该view会和原先的map关联紧密，并且该view是lazy的，也就是说，每次对该view进行操作（如遍历）的时候，该view才会对原先的map进行操作。来看一个例子：

object MapTest {

  val SEPERATOR = "----------------------"
  class ObjClass {
    def this(mem: String) = {
      this()
      this.member = mem
    }

    //表示该函数返回类型为该类类型
    def getSelf(): this.type = this

    var member: String = _

    override def toString: String = s"$member"
  }

  def main(args: Array[String]): Unit = {
    println(SEPERATOR)
    basicMapOp()
    println(SEPERATOR)

    val originMap = Map(1 -> new ObjClass("one"))
    println(SEPERATOR)
    println(s"m = $originMap")
    println(SEPERATOR)

    //返回的是一个view，并且该view和m强相关，后面每次调用m1，都会使得该view的mapValues被调用一次
    val mapValueMap = originMap.mapValues { a => a.member = "two"; println("1:" + a.member); a }
    println(s"m = $originMap")  //m = one
    println(s"m1=$mapValueMap")  //1: two
    mapValueMap.foreach { kv => kv._2.member = "three"; println("2:" + kv._2.member) } // 1:two 2:three
    println(s"m1=$mapValueMap") // 1:two，导致view又重新运行一遍
    println(SEPERATOR)
    //而transform就不会出现mapValues中的view情况， m2每次被调用，不会到导致transform又重新被运行一次。
    val transformMap = originMap.transform { (k, v) => v.member = "four"; v }
    //added by seancheer: 注意，这里不带.也是可以的
    //val m2 = m transform { (k, v) => v.f = "d"; v }
    println(s"m=$originMap")  //m = four
    originMap.foreach { kv => kv._2.member = "five!"}
    println(s"m2=$transformMap") // m2 = five, 返回的view是m的映射，因此修改m，m2也会被更新，同时，不会像mapValueMap那样，每调用一次，就运行一次
    println(s"m=$originMap")  //m = five
    println(SEPERATOR)
  }

}

​ 可以看到，mapValues返回的投影是lazy型的，每次使用一次返回后的mapValueMap，都会导致mapValues后面的方法体运行一次，从而导致originMap中的元素被重新更新为"two"，但是，transform方法返回的投影transformMap就没有这种情况。

​ 需要注意的是，这两个方法返回的都是originMap的一个投影（Projection），更新原始的originMap，会导致投影也发生变化。

转载于:https://www.cnblogs.com/seancheer/p/10868148.html