4.3 Scala集合：Map-知趣

Map是一个key-value 对的集合。在其它语言中，它被称为词典、关联数组、或HashMap。这是一个根据key查找value的高效的数据结构。

下面的代码段演示了怎样创建和使用一个Map：

val capitals = Map("美国" -> "华盛顿", "英国" -> "伦敦","中国" -> "北京")
val chinaCapital = capitals("中国")
println(chinaCapital)

下面这个示例是对Map进行迭代。

val booksMap = Map(101 -> "Scala", 102 -> "Spark")

val iterator = booksMap.keySet.iterator
while (iterator.hasNext) {
   var key = iterator.next
   // println(s"图书Id:$key,图书名称:${booksMap.get(key)}")
   println(s"图书Id:$key,图书名称:${booksMap(key)}")
}

输出如下所示：

图书Id:101,图书名称:Scala
图书Id:102,图书名称:Spark

【示例】创建使用不可变Map的示例。

object MapDemo {
  def main(args: Array[String]): Unit = {
    println("1: 初始化一个带有3个元素的Map - 使用key/value元组")
    // val map1: Map[String, String] = Map(("PG","苹果"),("XG","西瓜"),("PTG","葡萄干"))
    val map1 = Map(("PG","苹果"),("XG","西瓜"),("PTG","葡萄干")) // 类型推断
    println(s"map1的元素 = $map1")

    println("\n2: 使用key->value表示法初始化Map")
    // val map2: Map[String, String] = Map("PG" -> "苹果", "XG" -> "西瓜", "PTG" -> "葡萄干")
    val map2 = Map("PG" -> "苹果", "XG" -> "西瓜", "PTG" -> "葡萄干")
    println(s"map2的元素 = $map2")

    println("\n3: 通过特定键访问元素")
    println(s"Key是PG的元素 = ${map2("PG")}")
    println(s"Key是XG的元素 = ${map2("XG")}")
    println(s"Key是PTG的元素 = ${map2("PTG")}")
    println(s"Key是HLG的元素 = ${map2.get("HLG")}")     // 访问不存在的key
    println(s"Key是HLG的元素 = ${map2.getOrElse("HLG","火龙果")}")

    println("\n4: 使用 + 添加元素")
    // val map3: Map[String, String] = map1 + ("HLG" -> "火龙果")
    val map3: Map[String, String] = map1 + ("PTG" -> "火龙果") // 也可用来修改元素值
    println(s"map3 = $map3")

    println("\n5: 使用 ++ 将两个Map 添加到一起")
    val map4: Map[String, String] = map3 ++ map2
    println(s"map4 = $map4")

    println("\n6: 使用 - 从Map 删除key及其value")
    val map5: Map[String, String] = map4 - "PG"
    println(s"Map移除了PG key及其value = $map5")

    println("\n7: 初始化一个空的Map")
    val emptyMap: Map[String,String] = Map.empty[String,String]
    println(s"Empty Map = $emptyMap")
  }
}

【示例】如何遍历一个Map集合。

object Test {
  def main(args: Array[String]): Unit = {

    // map的遍历
    val map = Map(("aa",1),("bb",2),("cc",5),("dd",3))

    map.foreach { t =>
      val (x, y) = t
      println(s"key=$x, value=$y")
    }

    map.foreach { t =>
      println(s"k=${t._1}, v=${t._2}")
    }

    for(item <- map){
      val (x, y) = item
      println(s"key=$x,value=$y")
    }

    for((k,v) <- map){
      println(s"k = $k, v = $v")
    }

    for(key <- map.keySet){
      println(s"key=$key,value=${map(key)}")
    }

    for(item <- map){
      println(item)
    }

    for(item <- map){
      println(s"key=${item._1}, value=${item._2}")
    }

    for(v <- map.values){
      println(s"value=$v")
    }
  }
}

下面的代码示例演示的Map的创建和操作：

// 创建
var m1 = Map(("zhang3" -> 20), ("li4" -> 23), ("wang5" -> 21))
var m2 = Map(("zhang3", 20), ("li4", 23), ("wang5", 21))   // 也可使用元组创建

var m = scala.collection.mutable.Map(("zhang3", 20), ("li4", 23), ("wang5", 21))
// var m3 = scala.collection.mutable.Map[String, Int]()    // 定义空 map，要用可变的才有意义。

// 添加和更新：+=  ++=
m += (("zhao6", 22))
m ++= Map(("a" -> 1), ("b" -> 2))
m

// updated，没有增加，有了替换
m = m.updated("zheng7", 19)  // 和上面方法一样
m

m.put("wu", 22)
m

// 删除
m -= ("zhang3")     // 删除一个元素：按指定的key删除

m.clear()           // 清空
m

/* -- 查询 -- */
println("---------查询-------------")
var m4 = Map(("zhang3", 20), ("li4", 23), ("wang5", 21))
m4("zhang3")
// m4("aaa")        // 会出错，不友好
m4.get("aaa")       // 友好方式，推荐
m4.getOrElse("aaa",23)
m4.getOrElse("zhang3",23)

/* -- 遍历 -- */
var m5 = Map(("zhang3", 20), ("li4", 23), ("wang5", 21))

// 方法 1:直接打印 entry
for (entry <- m5) {
   println(entry) 
}

println("-------------")
// 方法 2：直接打印 key，顺手输出 value
for (key <- m5.keySet) {
    println(key + ":" + m5(key))
}

println("-------------")
for((k,v) <- m5){
    println(k + "," + v)
}

println("-------------")
// 方法 3.foreach
m5.foreach(e => {
   val (k, v) = e
   println(k + "," + v)
})

println("-------------")
// 方法 4
m5.foreach(e => println(e._1 + "," + e._2))

【示例】不可变的HashMap示例。

import scala.collection.immutable.HashMap

object HashMapDemo {
  def main(args: Array[String]): Unit = {
    println("1: 初始化一个带有3个元素的HashMap - 使用key/value元组")
    // val hashMap1: HashMap[String, String] = HashMap(("PG","苹果"),("XG","西瓜"),("PTG","葡萄干"))
    val hashMap1 = HashMap(("PG","苹果"),("XG","西瓜"),("PTG","葡萄干")) // 类型推断
    println(s"hashMap1的元素 = $hashMap1")

    println("\n2: 使用key->value表示法初始化Map")
    // val hashMap2: HashMap[String, String] = HashMap("PG" -> "苹果", "XG" -> "西瓜", "PTG" -> "葡萄干")
    val hashMap2 = HashMap("PG" -> "苹果", "XG" -> "西瓜", "PTG" -> "葡萄干")
    println(s"hashMap2的元素 = $hashMap2")

    println("\n3: 通过特定键访问元素")
    println(s"Key是PG的元素 = ${hashMap2("PG")}")
    println(s"Key是XG的元素 = ${hashMap2("XG")}")
    println(s"Key是PTG的元素 = ${hashMap2("PTG")}")
    println(s"Key是HLG的元素 = ${hashMap2.get("HLG")}")     // 访问不存在的key
    println(s"Key是HLG的元素 = ${hashMap2.getOrElse("HLG","火龙果")}")

    println("\n4: 使用 + 添加元素")
    // val hashMap3: HashMap[String, String] = hashMap1 + ("HLG" -> "火龙果")
    val hashMap3: HashMap[String, String] = hashMap1 + ("PTG" -> "火龙果") // 也可用来修改元素值
    println(s"hashMap3 = $hashMap3")

    println("\n5: 使用 ++ 将两个Map 添加到一起")
    val hashMap4: Map[String, String] = hashMap3 ++ hashMap2
    println(s"map4 = $hashMap4")

    println("\n6: 使用 - 从Map 删除key及其value")
    val hashMap5: Map[String, String] = hashMap4 - "PG"
    println(s"HashMap移除了PG key及其value = $hashMap5")

    println("\n7: 初始化一个空的Map")
    val emptyMap: HashMap[String,String] = HashMap.empty[String,String]
    println(s"Empty HashMap = $emptyMap")
  }
}

【示例】不可变的TreeMap示例。

import scala.collection.immutable.TreeMap

object TreeMapDemo {
  def main(args: Array[String]): Unit = {
      println("1: 初始化一个带有3个元素的HashMap - 使用key/value元组")
      // val treeMap1: TreeMap[String, String] = TreeMap(("PG","苹果"),("XG","西瓜"),("PTG","葡萄干"))
      val treeMap1 = TreeMap(("PG","苹果"),("XG","西瓜"),("PTG","葡萄干")) // 类型推断
      println(s"hashMap1的元素 = $treeMap1")

      println("\n2: 使用key->value表示法初始化Map")
      // val treeMap2: TreeMap[String, String] = TreeMap("PG" -> "苹果", "XG" -> "西瓜", "PTG" -> "葡萄干")
      val treeMap2 = TreeMap("PG" -> "苹果", "XG" -> "西瓜", "PTG" -> "葡萄干")
      println(s"hashMap2的元素 = $treeMap2")

      println("\n3: 通过特定键访问元素")
      println(s"Key是PG的元素 = ${treeMap2("PG")}")
      println(s"Key是XG的元素 = ${treeMap2("XG")}")
      println(s"Key是PTG的元素 = ${treeMap2("PTG")}")
      println(s"Key是HLG的元素 = ${treeMap2.get("HLG")}")     // 访问不存在的key
      println(s"Key是HLG的元素 = ${treeMap2.getOrElse("HLG","火龙果")}")

      println("\n4: 使用 + 添加元素")
      // val treeMap3: TreeMap[String, String] = hashMap1 + ("HLG" -> "火龙果")
      val treeMap3: TreeMap[String, String] = treeMap1 + ("PTG" -> "火龙果") // 也可用来修改元素值
      println(s"treeMap3 = $treeMap3")

      println("\n5: 使用 ++ 将两个TreeMap 添加到一起")
      val treeMap4: TreeMap[String, String] = treeMap3 ++ treeMap2
      println(s"treeMap4 = $treeMap4")

      println("\n6: 使用 - 从TreeMap 删除key及其value")
      val treeMap5: TreeMap[String, String] = treeMap4 - "PG"
      println(s"TreeMap移除了PG key及其value = $treeMap5")

      println("\n7: 将TreeMap的顺序改为降序")
      object AlphabetOrdering extends Ordering[String] {
          def compare(key1:String, key2:String): Int = key2.compareTo(key1)
      }
      val treeMap6: TreeMap[String, String] = TreeMap(
          ("PG","苹果"),
          ("XG","西瓜"),
          ("PTG","葡萄干")
      )(AlphabetOrdering)
      println(s"treeMap6的元素按降序排列 = $treeMap6")

      println("\n8: 初始化一个空的TreeMap")
      val mptyTreeMap: TreeMap[String,String] = TreeMap.empty[String,String]
      println(s"Empty TreeMap = $mptyTreeMap")
  }
}

【示例】不可变的ListMap示例。

import scala.collection.immutable.ListMap

object ListMapDemo {
  def main(args: Array[String]): Unit = {
    println("1: 初始化一个ListMap")
    val listMap1: ListMap[String, String] = ListMap(
      "PG" -> "苹果",
      "XG" -> "西瓜",
      "PTG" -> "葡萄干"
    )
    println(s"listMap1的元素 = $listMap1")

    println("\n2: 通过ListMap中的特定键访问元素")
    println(s"key PG对应的元素 = ${listMap1("PG")}")
    println(s"key XG对应的元素 = ${listMap1("XG")}")
    println(s"key PTG对应的元素 = ${listMap1("PTG")}")

    println("\n3: ListMap是一个递归数据结构")
    println(s"head of ListMap = ${listMap1.head}")  // 返回一个元组
    println(s"tail of ListMap = ${listMap1.tail}")

    println("\n4: 使用 + 向ListMap添加元素")
    // val listMap2: ListMap[String, String] = listMap1 + ("KD" -> "Krispy Kreme Donut")
    val listMap2 = listMap1 + ("HLG" -> "火龙果")
    println(s"listMap2的元素 = $listMap2")

    println("\n5: 使用 ++ 添加两个ListMap到一起")
    val listMap3: ListMap[String, String] = listMap1 ++ listMap2
    println(s"listMap3的元素 = $listMap3")

    println("\n6: 使用 - 从ListMap中删除key和value")
    val listMap4: ListMap[String, String] = listMap1 - "PG"
    println(s"没有PG及其值的ListMap = $listMap4")

    println("\n7: 初始化一个空的ListMap")
    val emptyListMap: ListMap[String, String] = ListMap.empty[String,String]
    println(s"key和value都是String类型的空ListMap = $emptyListMap")
  }
}

本站网络名称：知趣

本站永久网址： https://www.qubaa.top

网站侵权说明：本网站的文章部分内容可能来源于网络，仅供大家学习与参考，如有侵权，请联系站长删除处理。
1 本站一切资源不代表本站立场，并不代表本站赞同其观点和对其真实性负责。
2 本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报
3 本站资源大多存储在云盘，如发现链接失效，请联系我们我们会第一时间更新。

THE END