快学Scala 第五课 （构造映射，获取映射值，更新映射值，迭代映射，与Java互操作）

构造映射：

    val score = Map[String, Int]()
    val score1 = HashMap[String, Int]()

    val value1 = Map[String, Int]("aa" -> 1, "bb" -> 2)
    val value2 = Map[String, Int](("aa", 1), ("bb", 2))

获取映射值：

    println(if(value2.contains("cc")) value2("cc") else 0)
    println(value2.getOrElse("cc", 0))
    println(value2.getOrElse("aa", 0))

更新映射值：

    score1("aa") = 1
    score1("bb") = 2
    score1 += ("cc" -> 3, "dd" -> 4)
    score1 += (("cc", 3), ("dd", 4))
    score1 -= "cc"

迭代映射：

    for((k,v) <- value2){
      println(k)
      println(v)
    }

    value2.keySet
    println(value2.values)

    for (v <- value2.values) println(v)

    println(for ((k, v) <- value2 ) yield {(v, k)})

与Java互操作：(java.util.Properties 转 scala.collection.mutable.Map)

   val prop = new Properties()
    prop.put("aaa", "1")
    prop.put("bba", "2")

    import scala.collection.JavaConversions.propertiesAsScalaMap
    val scalaMap: scala.collection.mutable.Map[String, String] = prop
    scalaMap.foreach(println)

　　

时间： 2024-12-25 13:26:55

快学Scala 第五课 （构造映射，获取映射值，更新映射值，迭代映射，与Java互操作）的相关文章

快学Scala 第二十一课 （初始化trait的抽象字段）

初始化trait的抽象字段: trait Logged { println("Logged constructor") def log(msg: String){ println("Logged")} } trait FileLogger extends Logged { var filename: String override def log(msg: String) { println("filename:" + filename) } }

快学Scala 第六课 （类构造函数）

类 主构造器: class Person (var name: String){ } 主构造参数可以不带val或者var,如果没有被其他方法使用,则不保存为字段. 如果被其他方法使用,则被升格为字段,是private[this] val字段效果. 私有主构造: class Person private (var name: String){ } 辅助构造器: class Person (var name: String){ private var age = 0 def this(name: S

快学Scala 第十一课 （类继承）

类继承: class People { } class Emp extends People{ } 和Java一样,final的类不能被继承.final的字段和方法不能被override. 在Scala中重写一个非抽象方法必须使用override, 继承抽象方法前面加了override也没关系. abstract class Person { def say(s: String): Unit } class Worker extends Person{ override def say(s: S

快学Scala 第八课 （嵌套类）

嵌套类: class Human { class Student{ val age = 10 } } object ClassDemo { def main(args: Array[String]): Unit = { val h = new Human val s = new h.Student println(s.age) } } 有时会遇到这种情况: class Human { class Student { def addS(s: Student) = { val ab = new Ar

快学Scala 第十三课 （类型层级，对象相等性）

Scala 类型层级: 对象相等性: 和Java一样要重写equals方法和hashcode方法 class Student(val id: Int, val name: String) { override def equals(other: Any) = { val that = other.asInstanceOf[Student] if (that == null) false else id == that.id && name == that.name } override d

快学Scala 第十课 （包和包对象）

Scala包定义: 嵌套式: package a1 { class a1Class{ val age = 10 } package a2 { class PackageTest { def main(args: Array[String]): Unit = { println(new a1Class().age) } } } } 串联式: package com.citi.packageUtil 包对象: 包对象被编译成带有静态方法和字段的JVM类,名为package.class,位于相应的包下

快学Scala 第三课 （定长数组，变长数组, 数组循环, 数组转换, 数组常用操作）

定长数组定义: val ar = new Array[Int](10) val arr = Array("aa", "bb") 定长数组赋值: arr(0) = "cc" 变长数组定义: val ab = new ArrayBuffer[String]() val ab1 = ArrayBuffer[String]() 定长数组增加元素: ab += "aa" ab += ("bb", "cc&q

快学Scala 第十七课 （trait 入门）

trait 入门: trait类似于java的接口,不过比java接口功能更强大,可以有实体成员,抽象成员,实体方法,抽象方法. 如果需要混入的特质不止一个用with关键字. 带有特质的对象:(特质可以随时被混入对象中) trait Logged { def log(msg: String){} } trait ConsoleLogger extends Logged { override def log(msg: String){ println(msg) } } class SavingsA

快学Scala 第十九课 （trait的abstract override使用）

trait的abstract override使用: 当我看到abstract override介绍的时候也是一脸懵逼,因为快学scala,只介绍了因为TimestampLogger中调用的super.log依旧是个abstract class,所以必须在方法前加上abstract和override.但是并没有具体介绍如何使用,然后查阅了其他文档,才明白使用方法. 下面的代码定义了超类LoggerEmpty,这个定义意味着该特质只能混入扩展LoggerEmpty的类中. 在特质中声明抽象方法中有