Map 映射的使用

第3关：Map 映射的使用

100

• 任务要求
• 参考答案
• 评论8

• 任务描述
• 相关知识
  • Map 映射简介
  • 定义 Map
  • Map 的常用操作
    • 三个最基本的操作
    • 合并操作
    • 遍历 Map 的 keys 和 values
    • 常用方法列表
• 编程要求
• 测试说明

---

任务描述

本关任务：统计各单词出现的次数。

相关知识

Scala 提供了一套很好的集合实现，Scala 集合分为可变的和不可变的集合。可变集合可以在适当的地方被更新或扩展。也就是说你可以修改，添加，移除一个集合的元素。相比之下，不可变集合类永远不会改变。不过，

你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。在默认的情况下，Scala 使用的是不可变的集合类。本实训介绍的也是基于不可变集合类。

常见的集合类有 List 列表、Set 集合、Map 映射和元组等。接下来我们将为大家介绍第三种集合---Map 映射。

Map 映射简介

Map(映射)是一种可迭代的键值对（key/value）结构，它的所有的值都可以通过键来获取，且 Map 中的键都是唯一的。

定义 Map

以下代码演示了如何定义 Map 映射。

1. object ForDemo {
2. def main(args: Array[String]): Unit = {
3. // 定义一个空 Map 映射
4. var map: Map[Nothing, Nothing] =Map()
5. // 定义一个键为字符串，值为整型的 Map 映射
6. var people: Map[String, Int] =Map("张三"->34,"李四"->30)
7. println(map)
8. println(people)
9. }
10. }

执行结果：

1. Map()
2. Map(张三 -> 34, 李四 -> 30)

从以上代码中可以看到，Map 映射中的 key 值通过 “->” 指向 value 值。

Map 的常用操作

三个最基本的操作

Scala Map 有三个基本操作：

方法	描述
keys	返回 Map 所有的键(key)
values	返回 Map 所有的值(value)
isEmpty	在 Map 为空时返回true

这些基本的操作可应用于任何 Map 映射。实例如下:

1. object Test {
2. def main(args: Array[String]) {
3. val colors = Map("red" -> "#FF0000",
4. "azure" -> "#F0FFFF",
5. "peru" -> "#CD853F")
7. val nums: Map[Int, Int] = Map()
9. println( "colors 中的所有键 : " + colors.keys )
10. println( "colors 中的所有值 : " + colors.values )
11. println( "检测 colors 是否为空 : " + colors.isEmpty )
12. println( "检测 nums 是否为空 : " + nums.isEmpty )
13. }
14. }

执行结果：

1. colors 中的所有键 : Set(red, azure, peru)
2. colors 中的所有值 : MapLike(#FF0000, #F0FFFF, #CD853F)
3. 检测 colors 是否为空 : false
4. 检测 nums 是否为空 : true

合并操作

合并两个或者多个 Map 有两种方式：一是使用 ++ 运算符，二是使用.++() 方法。Map 合并时会移除重复的 key。

1. val colors1 = Map("red" -> "#FF0000",
2. "azure" -> "#F0FFFF",
3. "peru" -> "#CD853F")
4. val colors2 = Map("blue" -> "#0033FF",
5. "yellow" -> "#FFFF00",
6. "red" -> "#FF00001")
8. // 使用 ++ 运算符合并
9. var colors = colors1 ++ colors2
10. println( "colors1 ++ colors2 : " + colors )
12. // 使用 .++ 方法合并
13. colors = colors1.++(colors2)
14. println( "colors1.++(colors2)) : " + colors )

执行结果：

1. colors1 ++ colors2 : Map(blue -> #0033FF, azure -> #F0FFFF, peru -> #CD853F, yellow -> #FFFF00, red -> #FF00001)
2. colors1.++(colors2)) : Map(blue -> #0033FF, azure -> #F0FFFF, peru -> #CD853F, yellow -> #FFFF00, red -> #FF00001)

从运行结果可以看到：两个 Map 映射中都有相同的 key 值 red，尽管 value 值不同，合并后依然移除了第一个重复的 key。

遍历 Map 的 keys 和 values

使用 foreach 循环，可以遍历 Map 中的 keys 和 values。

1. object ForDemo {
2. def main(args: Array[String]): Unit = {
3. val sites = Map("educoder" -> "www.educoder.net",
4. "baidu" -> "http://www.baidu.com",
5. "taobao" -> "http://www.taobao.com")
6. // 使用 foreach 遍历 Map 中的 keys 和 values
7. sites.keys.foreach{ i =>
8. print( "Key = " + i )
9. println(" Value = " + sites(i) )}
10. }
11. }

执行结果：

1. Key = educoder Value = www.educoder.net
2. Key = baidu Value = http://www.baidu.com
3. Key = taobao Value = http://www.taobao.com

以上代码中，通过 sites.keys 可以获取到 Map 映射的所有 key 值，通过 keys.foreach 可以遍历每一个 key 值，并把每个 key 值（中括号里的 i）应用于 foreach 后的代码，value 值通过 sites(i) 获取（即使用映射名+（key值）获取）。

常用方法列表

方法	描述
def ++(xs: Map[(A, B)]): Map[A, B]	返回一个新的 Map，新的 Map xs 组成
def -(elem1: A, elem2: A, elems: A*): Map[A, B]	返回一个新的 Map, 移除 key 为 elem1, elem2 或其他 elems
def –(xs: GTO[A]): Map[A, B]	返回一个新的 Map, 移除 xs 对象中对应的 key
def get(key: A): Option[B]	返回指定 key 的值
def iterator: Iterator[(A, B)]	创建新的迭代器，并输出 key/value 对
def apply(key: A): B	返回指定键的值，如果不存在返回 Map 的默认方法
def clear(): Unit	清空 Map
def clone(): Map[A, B]	从一个 Map 复制到另一个 Map
def contains(key: A): Boolean	如果 Map 中存在指定 key，返回 true，否则返回 false
def copyToArray(xs: Array[(A, B)]): Unit	复制集合到数组
def count(p: ((A, B)) => Boolean): Int	计算满足指定条件的集合元素数量
def drop(n: Int): Map[A, B]	返回丢弃前n个元素新集合
def dropWhile(p: ((A, B)) => Boolean): Map[A, B]	从左向右丢弃元素，直到条件p不成立
def equals(that: Any): Boolean	如果两个 Map 相等(key/value 均相等)，返回true，否则返回false
def exists(p: ((A, B)) => Boolean): Boolean	判断集合中指定条件的元素是否存在
def filter(p: ((A, B))=> Boolean): Map[A, B]	返回满足指定条件的所有集合
def filterKeys(p: (A) => Boolean): Map[A, B]	返回符合指定条件的的不可变 Map
def find(p: ((A, B)) => Boolean): Option[(A, B)]	查找集合中满足指定条件的第一个元素
def foreach(f: ((A, B)) => Unit): Unit	将函数应用到集合的所有元素
def init: Map[A, B]	返回所有元素，除了最后一个
def isEmpty: Boolean	检测 Map 是否为空
def keys: Iterable[A]	返回所有的key
def last: (A, B)	返回最后一个元素
def max: (A, B)	查找最大元素
def min: (A, B)	查找最小元素
def remove(key: A): Option[B]	移除指定 key
def size: Int	返回 Map 元素的个数
def sum: (A, B)	返回集合中所有数字元素之和
def tail: Map[A, B]	返回一个集合中除了第一元素之外的其他元素
def take(n: Int): Map[A, B]	返回前 n 个元素
def takeWhile(p: ((A, B)) => Boolean): Map[A, B]	返回满足指定条件的元素
def toArray: Array[(A, B)]	集合转数组
def toBuffer[B >: A]: Buffer[B]	返回缓冲区，包含了 Map 的所有元素
def toList: List[A]	返回 List，包含了 Map 的所有元素
def toSeq: Seq[A]	返回 Seq，包含了 Map 的所有元素
def toSet: Set[A]	返回 Set，包含了 Map 的所有元素
def toString(): String	返回字符串对象

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 间编写程序代码，统计给定字符串中每个单词出现的次数，具体要求如下：

• 接收给定的一行字符串（例：hello-hello,hi,job-hi,...，依次切割英文逗号和“-”，可以得到每个单词）；
• 统计各单词出现的次数。

测试说明

平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。

例： 测试输入：

1. hello-hello,hi,job-hi

预期输出：

1. 单词： hi, 个数 1
2. 单词： hello, 个数 2

---

开始你的任务吧，祝你成功！

import scala.io.StdIn

object ForDemo {

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

    // 请在 Begin-End 间编写代码

    /********** Begin **********/

    val input = StdIn.readLine()

    val words = input.split(",|-")

    val wordCount = words.groupBy(identity).mapValues(_.length)

    wordCount.foreach { case (word, count) =>

      println(s"单词： $word, 个数 $count")

    }

    /********** End **********/

  }

}