Scala当中的Map 映射

た入场券 2023-03-13 03:49 32阅读 0赞

key -> value 的语法形式实际上是用库中的隐式转换实现的，实际调用了 Map.apply 方法。Map.apply 方法的参数为一个两元素的元组（键值对）。

map 的参数是一个函数，以上示例展示了定义这个函数的两种方法。每个键值对（元组）都将被传入到该函数中。我们可以将其参数定义为一个两元素的元组，

map定义：其中当出现同一个key值的时候，后面的值会将前面的值进行覆盖。使用foreach进行遍历

val map =Map[String,Int]("a"->100,"b"->200,("c",300),("c",400))

![在这里插入图片描述][20200510214741447.png]  
根据key返回value值，使用的是一个get,这个时候如果存在对应的值就会返回一个Some类型的值，反之则是一个None，这俩个类型都是Option的子类。最后再.get就会返回对应的基本类型。

map.get("a")
    map.get("aa")
    map.get("a").get

![在这里插入图片描述][2020051021564838.png]  
当对一个不存在的key获取他的值的时候，很显然是会报错的，这个时候可以使用 `,getOrElse()`方法，表示当不存在的时候，返回这个方法里面的东西。

map.get("aa").getOrElse("不存在")

![在这里插入图片描述][20200510220100370.png]  
获取所有的key，使用`.keys`方法，返回值的类型是一个 Iterable \[String\]  
根据所获取的key值打印出所对应的value值

map.keys.foreach(key => { 
          println(map.get(key))
        })

![在这里插入图片描述][20200510220622988.png]  
俩个map映射合并  
其中`.++`是表示将map1往map里面合并，即map1覆盖map，而原本的`.++:`是表示map往map1里面添加，map覆盖map1，但是在这里弹出警告：trait MapOps中的method`++：`已弃用（从2.13.0开始）：对于Iterable类型的集合，请使用`++`而不是`++：`方法。

注： 如果一个包含 + 的表达式返回结果类型 String，而这并不是你所期望的结果。这可能是因为编译器认为这是该表达式唯一可行的解析方式，就把 + 两边的子表达式转为字符串，再相加。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTczMTU5_size_16_color_FFFFFF_t_70]  
可变长的Map，导入对应的Map包，使用put方法进行添加元素

import scala.collection.mutable.Map
        val map = Map[String,Int]()
        map.put("a",4)
        map.put("b",7)
        map.foreach(println)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTczMTU5_size_16_color_FFFFFF_t_70 1]  
可变长度的map映射的filter过滤，当使用的是命令行的时候，没有换行输入的话，需要家伙少年宫分号进行隔开，在最后可以看到返回值的类型会是一个 scala.collection.mutable.Map\[String,Int\]

map.filter(tp => { 
          val key = tp._1
          val value = tp._2 
          value == 4
        })

![在这里插入图片描述][202005111028571.png]  
其余的Map方法：如下表所示

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

[20200510214741447.png]: /images/20230312/fa2e59f0e647439da6389b85c5bbce31.png
[2020051021564838.png]: /images/20230312/b135d426020e4302907a915993bb828c.png
[20200510220100370.png]: /images/20230312/fc5cb8bd18e1487194616bb431b23cd6.png
[20200510220622988.png]: /images/20230312/2e0c3bb002a44acf8ed18f00d31674e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTczMTU5_size_16_color_FFFFFF_t_70]: /images/20230312/d26c46d697754eee9211d2ca879c50d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTczMTU5_size_16_color_FFFFFF_t_70 1]: /images/20230312/d2442570409b4ba4a487f3468f9dd942.png
[202005111028571.png]: /images/20230312/f0512706f91b44c5a8df075ece1cb987.png