Scala中的映射map

古城微笑少年丶 2022-11-18 13:43 207阅读 0赞

# 1.定义： #

映射是一系列 键值对的容器

map中的Key是唯一的

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70][]

分为可变map和 不可变map

可变集合：scala.collection.mutable.map

不可变集合：scala.collection.immutable.map

默认使用 不可变集合, 使用可变map需要先导入 可变包 scala.collection.mutable.map

import scala.collection.mutable.map

val map2 = scala.collection.mutable.Map("name"->"zhangsan","gender"-> 2)
    map2 +=("age" -> 12)   //use += add elements
    
    map2.foreach(println(_))

# 2.声明map #

val map1 = Map("name" -> "zhangsan", "age" -> "10")
    map1.foreach(println(_))

输出：

![20210413143346206.png][]

# 3.获取map元素 #

## 3.1使用key获取value ##

eg:

val map1 = Map("name" -> "zhangsan", "age" -> "10")
    println(map1("name"))

输出：

![20210413144613833.png][]

ps：如果key 不存在会报错， 所以可以先判断下 key是否存在

val map1 = Map("name" -> "zhangsan", "age" -> "10")
    println(map1("gender"))

![20210413145115670.png][]

不确定key是否存在，需要先判断

## 查看 Map 中是否存在指定的 Key ##

eg：

val map1 = Map("name" -> "zhangsan", "age" -> "10")
    
    println(if(map1.contains("gender")) map1("gender") else 0 )

输出：

![20210413150250145.png][]

## 3.2获取所有的keys ##

eg:
    
    /*get all keys*/

val map1 = Map("name" -> "zhangsan", "age" -> "10")
    println(map1.keys)

ps: 返回的是set集合

输出：

![20210413144458219.png][]

## 3.3 获取所有的values ##

eg:

val map2 = Map("name" -> "zhangsan", "age" -> "10")
    println(map2.values)

输出：

![20210413151015548.png][]

## 3.4 检查map是否为空 ##

eg:

/*isEmpty*/

val map1 = Map("name" -> "zhangsan", "age" -> "10")
    println(map1.isEmpty)

输出：

![20210413150633712.png][]

## 3.5两个map的合并 ##

使用  ++  合并

eg:

val map2 =Map("name" -> "hangman2", "age" -> "10","gender"->1)
    val map3 = Map("name" -> "zhangsan3", "age" -> "10")
    val map4 = map2 ++ map3
    map4.foreach(println(_))

输出：

![2021041315184320.png][]

ps:  如果key重复，++ 后者会替换掉 前边的key 对应的value

## 3.6 获取map中所有的keys 和  values ##

eg:

val map2 =Map("name" -> "hangman2", "age" -> "10","gender"->1)
    map2.keys.foreach(i => {
    
      print("key is ", i)
      println("value is ", map2(i))
      
    })

输出：

![20210413153121514.png][]

eg2:

val map2 =Map("name" -> "hangman2", "age" -> "10","gender"->1)
    map2.keys.foreach(i =>{
    
      if(i.equals("name")){
        println("这里是 name 的value ",map2(i))
      }else{print("key is ",i)
        println("value is ",map2(i))
      }}
    
    )

输出：

![20210413153054252.png][]

## 3.6 exists 判断集合中指定条件的元素是否存在 ##

eg：

/*exists*/
    val map2 =Map("name" -> "hangman2", "age" -> "10","gender"->1)
    println(map2.exists(x => x._1 == "age" && x._2 == "10") )  //judge the key and the key's value  equals a special thing

输出：

![2021041316491567.png][]

## 3.7  **filter **返回满足指定条件的所有集合 ##

<table> 
 <tbody> 
 <tr> 
 <td> def filter(p: ((A, B))=&gt; Boolean): Map[A, B] 返回满足指定条件的所有集合 </td> 
 </tr> 
 </tbody> 
</table>

eg:
    
    val map2 = Map("name" -> "hangman2", "age" -> "10","gender"->1)
    println(map2.filter(x => x._1 == "name"))

输出：

![20210413174455490.png][]

ps： 如果过滤掉 key为空的元素，用nonEmpty

val resultMap2 = resultMap1.filter(x  => x._1.nonEmpty)

如果获取key为 空， 用isEmpty

val resultMap2 = resultMap1.filter(x  => x._1.isEmpty)

## 3.8 遍历 ##

val map1 = Map("zs"->"张三","ls"->"李四","ww"->"王五")
    /*1*/
    map1 foreach (x=>println(x._1,x._2))
    
    /*2*/
    map1 foreach {x => x match {
      case (k,v) => {println(k,v)}
    }}
    
    /*3*/
    map1 foreach {
      case (k, v) => {
        println(k, v)
      }
    }

输出：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 1][]

## 3.9 排序 ##

### 从小到大 ###

val resultMap3 = resultMap2.toList.sortBy(_._2)

![20210507103450836.png][]

### 从大到小 ###

val resultMap3 = resultMap2.toList.sortBy(-_._2)

![20210507103402997.png][]

对map的操作：

[https://blog.csdn.net/hzp666/article/details/116481796][https_blog.csdn.net_hzp666_article_details_116481796]

<table> 
 <tbody> 
 <tr> 
 <th>序号</th> 
 <th>方法及描述</th> 
 </tr> 
 <tr> 
 <td>1</td> 
 <td> def ++(xs: Map[(A, B)]): Map[A, B] 返回一个新的 Map，新的 Map xs 组成 </td> 
 </tr> 
 <tr> 
 <td>2</td> 
 <td> def -(elem1: A, elem2: A, elems: A*): Map[A, B] 返回一个新的 Map, 移除 key 为 elem1, elem2 或其他 elems。 </td> 
 </tr> 
 <tr> 
 <td>3</td> 
 <td> def --(xs: GTO[A]): Map[A, B] 返回一个新的 Map, 移除 xs 对象中对应的 key </td> 
 </tr> 
 <tr> 
 <td>4</td> 
 <td> def get(key: A): Option[B] 返回指定 key 的值 </td> 
 </tr> 
 <tr> 
 <td>5</td> 
 <td> def iterator: Iterator[(A, B)] 创建新的迭代器，并输出 key/value 对 </td> 
 </tr> 
 <tr> 
 <td>6</td> 
 <td> def addString(b: StringBuilder): StringBuilder 将 Map 中的所有元素附加到StringBuilder，可加入分隔符 </td> 
 </tr> 
 <tr> 
 <td>7</td> 
 <td> def addString(b: StringBuilder, sep: String): StringBuilder 将 Map 中的所有元素附加到StringBuilder，可加入分隔符 </td> 
 </tr> 
 <tr> 
 <td>8</td> 
 <td> def apply(key: A): B 返回指定键的值，如果不存在返回 Map 的默认方法 </td> 
 </tr> 
 <tr> 
 <td>9</td> 
 <td> def clear(): Unit 清空 Map </td> 
 </tr> 
 <tr> 
 <td>10</td> 
 <td> def clone(): Map[A, B] 从一个 Map 复制到另一个 Map </td> 
 </tr> 
 <tr> 
 <td>11</td> 
 <td> def contains(key: A): Boolean 如果 Map 中存在指定 key，返回 true，否则返回 false。 </td> 
 </tr> 
 <tr> 
 <td>12</td> 
 <td> def copyToArray(xs: Array[(A, B)]): Unit 复制集合到数组 </td> 
 </tr> 
 <tr> 
 <td>13</td> 
 <td> def count(p: ((A, B)) =&gt; Boolean): Int 计算满足指定条件的集合元素数量 </td> 
 </tr> 
 <tr> 
 <td>14</td> 
 <td> def default(key: A): B 定义 Map 的默认值，在 key 不存在时返回。 </td> 
 </tr> 
 <tr> 
 <td>15</td> 
 <td> def drop(n: Int): Map[A, B] 返回丢弃前n个元素新集合 </td> 
 </tr> 
 <tr> 
 <td>16</td> 
 <td> def dropRight(n: Int): Map[A, B] 返回丢弃最后n个元素新集合 </td> 
 </tr> 
 <tr> 
 <td>17</td> 
 <td> def dropWhile(p: ((A, B)) =&gt; Boolean): Map[A, B] 从左向右丢弃元素，直到条件p不成立 </td> 
 </tr> 
 <tr> 
 <td>18</td> 
 <td> def empty: Map[A, B] 返回相同类型的空 Map </td> 
 </tr> 
 <tr> 
 <td>19</td> 
 <td> def equals(that: Any): Boolean 如果两个 Map 相等(key/value 均相等)，返回true，否则返回false </td> 
 </tr> 
 <tr> 
 <td>20</td> 
 <td> def exists(p: ((A, B)) =&gt; Boolean): Boolean 判断集合中指定条件的元素是否存在 </td> 
 </tr> 
 <tr> 
 <td>21</td> 
 <td> def filter(p: ((A, B))=&gt; Boolean): Map[A, B] 返回满足指定条件的所有集合 </td> 
 </tr> 
 <tr> 
 <td>22</td> 
 <td> def filterKeys(p: (A) =&gt; Boolean): Map[A, B] 返回符合指定条件的不可变 Map </td> 
 </tr> 
 <tr> 
 <td>23</td> 
 <td> def find(p: ((A, B)) =&gt; Boolean): Option[(A, B)] 查找集合中满足指定条件的第一个元素 </td> 
 </tr> 
 <tr> 
 <td>24</td> 
 <td> def foreach(f: ((A, B)) =&gt; Unit): Unit 将函数应用到集合的所有元素 </td> 
 </tr> 
 <tr> 
 <td>25</td> 
 <td> def init: Map[A, B] 返回所有元素，除了最后一个 </td> 
 </tr> 
 <tr> 
 <td>26</td> 
 <td> def isEmpty: Boolean 检测 Map 是否为空 </td> 
 </tr> 
 <tr> 
 <td>27</td> 
 <td> def keys: Iterable[A] 返回所有的key/p&gt; </td> 
 </tr> 
 <tr> 
 <td>28</td> 
 <td> def last: (A, B) 返回最后一个元素 </td> 
 </tr> 
 <tr> 
 <td>29</td> 
 <td> def max: (A, B) 查找最大元素 </td> 
 </tr> 
 <tr> 
 <td>30</td> 
 <td> def min: (A, B) 查找最小元素 </td> 
 </tr> 
 <tr> 
 <td>31</td> 
 <td> def mkString: String 集合所有元素作为字符串显示 </td> 
 </tr> 
 <tr> 
 <td>32</td> 
 <td> def product: (A, B) 返回集合中数字元素的积。 </td> 
 </tr> 
 <tr> 
 <td>33</td> 
 <td> def remove(key: A): Option[B] 移除指定 key </td> 
 </tr> 
 <tr> 
 <td>34</td> 
 <td> def retain(p: (A, B) =&gt; Boolean): Map.this.type 如果符合满足条件的返回 true </td> 
 </tr> 
 <tr> 
 <td>35</td> 
 <td> def size: Int 返回 Map 元素的个数 </td> 
 </tr> 
 <tr> 
 <td>36</td> 
 <td> def sum: (A, B) 返回集合中所有数字元素之和 </td> 
 </tr> 
 <tr> 
 <td>37</td> 
 <td> def tail: Map[A, B] 返回一个集合中除了第一元素之外的其他元素 </td> 
 </tr> 
 <tr> 
 <td>38</td> 
 <td> def take(n: Int): Map[A, B] 返回前 n 个元素 </td> 
 </tr> 
 <tr> 
 <td>39</td> 
 <td> def takeRight(n: Int): Map[A, B] 返回后 n 个元素 </td> 
 </tr> 
 <tr> 
 <td>40</td> 
 <td> def takeWhile(p: ((A, B)) =&gt; Boolean): Map[A, B] 返回满足指定条件的元素 </td> 
 </tr> 
 <tr> 
 <td>41</td> 
 <td> def toArray: Array[(A, B)] 集合转数组 </td> 
 </tr> 
 <tr> 
 <td>42</td> 
 <td> def toBuffer[B &gt;: A]: Buffer[B] 返回缓冲区，包含了 Map 的所有元素 </td> 
 </tr> 
 <tr> 
 <td>43</td> 
 <td> def toList: List[A] 返回 List，包含了 Map 的所有元素 </td> 
 </tr> 
 <tr> 
 <td>44</td> 
 <td> def toSeq: Seq[A] 返回 Seq，包含了 Map 的所有元素 </td> 
 </tr> 
 <tr> 
 <td>45</td> 
 <td> def toSet: Set[A] 返回 Set，包含了 Map 的所有元素 </td> 
 </tr> 
 <tr> 
 <td>46</td> 
 <td> def toString(): String 返回字符串对象 </td> 
 </tr> 
 </tbody> 
</table>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70]: /images/20221022/9d4e6a4b2e7c450497428d099a6bd4c8.png
[20210413143346206.png]: /images/20221022/9add13f99dea48eb971bef00431cf152.png
[20210413144613833.png]: /images/20221022/d6c8de00c6144a44985b516dcc82acab.png
[20210413145115670.png]: /images/20221022/f249779183b448adb1bfb6b4eb96bcec.png
[20210413150250145.png]: /images/20221022/e66dbf7033e2493f897ecac7aca2ff40.png
[20210413144458219.png]: /images/20221022/655a2ddfe1be462399a2dd51d0c79373.png
[20210413151015548.png]: /images/20221022/d739dee1161f42b8b4bf0b06d1d626b0.png
[20210413150633712.png]: /images/20221022/bd7c5ce3e8004d95b5f53ce1e579adce.png
[2021041315184320.png]: /images/20221022/044ef896406e49bf95246b911affdb7c.png
[20210413153121514.png]: /images/20221022/ed5d205a08f447a9b92d01fdbfc88e97.png
[20210413153054252.png]: /images/20221022/5a8951be4afb40fbbb2974d1d7026809.png
[2021041316491567.png]: /images/20221022/ff52faf2cba04cd9afdffba5fa0d5f2a.png
[20210413174455490.png]: /images/20221022/84dba017d59147868a61db82828a67a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6cDY2Ng_size_16_color_FFFFFF_t_70 1]: /images/20221022/1bc079f7f7ba4d24a7db682d8d228819.png
[20210507103450836.png]: /images/20221022/ac186c7096f245fbb02ccf57922548a8.png
[20210507103402997.png]: /images/20221022/fb1f717e368140149353a037622f3bad.png
[https_blog.csdn.net_hzp666_article_details_116481796]: https://blog.csdn.net/hzp666/article/details/116481796