Scala009--Scala中的数据结构【映射】

最新推荐文章于 2024-07-10 19:13:47 发布

码到成龚

最新推荐文章于 2024-07-10 19:13:47 发布

阅读量1.3k

点赞数

分类专栏： Scala-大数据spark基础文章标签： scala 开发语言后端

本文链接：https://blog.csdn.net/weixin_53046747/article/details/127888064

版权

Scala-大数据spark基础专栏收录该内容

14 篇文章 8 订阅

订阅专栏

2，获取map集合中key对应的value值

1）使用小括号的形式

2）使用get函数的形式

3）使用getOrElse函数

4）向map集合中添加key，value [ +（key -> value）]

5）删除集合中key键对应的值value [-(key)]

6）数据类型强转 .asInstanceOf[数据类型]

1，向可变映射中添加元素【put(key,value)】

2，从可变映射中删除元素 [remove(key)]

3，使用+=函数添加多个元素

4，使用-=函数删除多个元素

六，映射的遍历

1，获取映射中的key 【keySet函数/keys函数】

2，获取映射中的键值对【不使用函数】

3，获取映射中的value值【values函数】

七，将对偶的序列转换成map映射【toMap函数】

1，将含有对偶元组的数组转换成映射

2，将含有对偶元组的列表转换成map映射

一，概述

Scala中的映射其实就是map集合，它的使用和Java中的map一样，但是在Scala中它依旧和之前的几种数据结构：列表，数组，集合一样，有着两种形式，一种是可变的map，另外一种是不可变的map。接下来我们先来认识不可变的map。

二，map的声明

在Scala中，map和set一样，虽然是个接口，但是依旧可以直接使用它创建一个数据。

1，不可变map

scala> val map_im=Map("张三" -> "一等奖","李四" ->("二等奖","特等奖"))  // 声明一个不可变map集合
map_im: scala.collection.immutable.Map[String,java.io.Serializable] = Map(张三 -> 一等奖, 李四 -> (二等奖,特等奖))

如上，我们可以看到，在声明map集合的时候，不同于数组，列表，集合，它需要传入两个值，key -> value，并且，如果value比较多的话可以使用小括号包裹起来。

对于不可变的map来说，它的元素是不可以改变的，如下，当我们试图去修改map中key对应的value值时就会报错：

error: value update is not a member of

scala.collection.immutable.Map[String,java.io.Serializable]

三，HashMap的声明

1，可变hashmap

我们在使用可变的映射hashmap的时候需要导入相关的包才行，不然就会报错，并告诉我们找不到该类型：

当我们导入包之后：import scala.collection.mutable.HashMap。

再去使用动态和静态的方法创建映射就可以成功：

scala> import scala.collection.mutable.HashMap  // 导入可变的hashmap
import scala.collection.mutable.HashMap

scala> val  map_hash=HashMap("北京" -> "10k")
map_hash: scala.collection.mutable.HashMap[String,String] = Map(北京 -> 10k)

scala> val ma_hash1=new HashMap[String,Int]  // 动态创建hashmap映射
ma_hash1: scala.collection.mutable.HashMap[String,Int] = Map()

可变的hashmap和之前的可变列表，可变数组都一样，有很多的可用函数用于对数据结构中的数据更改。如put函数用于添加数据，remove函数用于删除等。

四，map常用函数

1，查看map中的元素个数 size

size函数很通用，在Scala中的其他数据结构中，如数组，列表，集合，查看元素个数都可以使用size函数来进行查看。

scala> val map_im=Map("张三" -> "一等奖","李四" ->("二等奖","特等奖"))  // 声明一个不可变map集合
map_im: scala.collection.immutable.Map[String,java.io.Serializable] = Map(张三 -> 一等奖, 李四 -> (二等奖,特等奖))

scala> map_im.size
res0: Int = 2

如上，在map集合中使用size函数返回map集合中的元素个数即map集合中的key。

2，获取map集合中key对应的value值

1）使用小括号的形式

scala> map_im
res1: scala.collection.immutable.Map[String,java.io.Serializable] = Map(张三 -> 一等奖, 李四 -> (二等奖,特等奖))

scala> map_im("张三")  // 获取张三的信息，如果有则返回，没有相应的key则报错
res2: java.io.Serializable = 一等奖

scala> map_im("王五")   // map集合中没有的key
java.util.NoSuchElementException: key not found: 王五
  at scala.collection.immutable.Map$Map2.apply(Map.scala:184)
  ... 28 elided

scala>

如上，我们可以看到，当我们使用小括号的形式去获取map集合中没有key键对应的value值的时候会给我们报错，但是有些时候我们不想要这种报错（看起来怪难看的），这个时候就需要使用另外两种不同的函数来解决这种问题。我们接着看：

2）使用get函数的形式

get函数返回的值只有两种，一种是找到有key的value值：some(value/values)，另外一种就是找不到的：none，如下：

返回none


scala> map_im("王五")   // map集合中没有的key
java.util.NoSuchElementException: key not found: 王五
  at scala.collection.immutable.Map$Map2.apply(Map.scala:184)
  ... 28 elided

scala> map_im
res9: scala.collection.immutable.Map[String,java.io.Serializable] = Map(张三 -> 一等奖, 李四 -> (二等奖,特等奖))

scala> map_im.get("王五")
res10: Option[java.io.Serializable] = None

返回some

scala> map_im.get("张三")
res0: Option[java.io.Serializable] = Some(一等奖)

当找不到的时候如果不想只返回none结果，还想要再返回相应的提示，那么我们就可以使用getOrElse函数，里面可以传入两个参数。

3）使用getOrElse函数

getOrElse函数，里面需要传入两个参数，第一个是要查找的key对应的value值，第二个是如果找不到对应的value值则返回自定义的返回，如下，我们查找存在的张三和不存在的王五：


scala> map_im.getOrElse("张三","抱歉该选手未注册")
res2: java.io.Serializable = 一等奖

scala> map_im.getOrElse("王五","抱歉该选手未注册")
res3: java.io.Serializable = 抱歉该选手未注册

4）向map集合中添加key，value [ +（key -> value）]

对于不可变map映射来说，添加或者是减去任何元素都不会对原有的集合产生任何影响，但是我们可以使用新的变量来接收产生的集合结果。

不可变map集合中添加元素：

scala> map_im + ("张三壹号" -> 19)
res10: scala.collection.immutable.Map[String,Int] = Map(张三 -> 18, 李四 -> 20, 张三壹号 -> 19)

scala> map_im
res11: scala.collection.immutable.Map[String,Int] = Map(张三 -> 18, 李四 -> 20)

如上，我们向map_im集合中添加元素之后再去查看该集合，就会发现该集合中没有添加“张三壹号”相应的key和value。

5）删除集合中key键对应的值value [-(key)]

不可变map集合中删除元素：

删除map映射中的元素只需要给定一个key即可，不用像之前添加函数那样需要写两个参数。

scala> map_im
res11: scala.collection.immutable.Map[String,Int] = Map(张三 -> 18, 李四 -> 20)

scala> map_im -("张三")
res12: scala.collection.immutable.Map[String,Int] = Map(李四 -> 20)

scala> map_im
res13: scala.collection.immutable.Map[String,Int] = Map(张三 -> 18, 李四 -> 20)

6）数据类型强转 .asInstanceOf[数据类型]

scala> map_im("张三").asInstanceOf[Double]  //   将int类型的数据强转为double类型
res14: Double = 18.0

scala> map_im("张三")
res15: Int = 18

7）同类序列的拼接 ++

scala> val map_im1=Map("赵六" -> 100)
map_im1: scala.collection.immutable.Map[String,Int] = Map(赵六 -> 100)

scala> map_im
res16: scala.collection.immutable.Map[String,Int] = Map(张三 -> 18, 李四 -> 20)

scala> // 使用++ 对两个同类的序列进行拼接

scala> map_im ++ map_im1
res17: scala.collection.immutable.Map[String,Int] = Map(张三 -> 18, 李四 -> 20, 赵六 -> 100)

8）判断映射是否为空 isEmpty

isEmpty函数不需要传入参数，返回值只有两种：①如果为空则返回true②如果不为空则返回false

scala> map_im
res43: scala.collection.immutable.Map[String,Int] = Map(张三 -> 18, 李四 -> 20)

scala> map_im.isEmpty
res44: Boolean = false

五，hashmap常用函数

1，向可变映射中添加元素【put(key,value)】

当在可变映射中进行添加或者是删除操作的时候，都会对原来的数据结构造成影响。如下我们使用put函数向一个没有数据的hashmap映射中添加元素，之后再去查看该数据结构就会发现多了一对key，value值。

scala> // 使用put方法向可变hashmap中添加元素

scala> ma_hash1.put("上海",11000)
res21: Option[Int] = None

scala> ma_hash1
res22: scala.collection.mutable.HashMap[String,Int] = Map(上海 -> 11000)

如上，我们可以看到，添加成功之后会有一个返回值：none，这个不用管，表示我们的添加是成功的，并且还是第一次添加。如果是向hashmap映射中添加已经存在的键值对的话就会是另外一种输出：

如上，当第二次去添加的话就会返回映射中已经存在的键值对。

2，从可变映射中删除元素 [remove(key)]

remove函数只需要我们向里面传入一个参数，那就是想要删除的key。如下，我们使用remove函数删除ma_hash1映射中的"上海"所对应的键和值：


scala> ma_hash1
res35: scala.collection.mutable.HashMap[String,Int] = Map(上海 -> 11000, 珠海 -> 3333, 广州 -> 3, 深圳 -> 33333)

scala> ma_hash1.remove("上海")
res36: Option[Int] = Some(11000)

scala> ma_hash1
res37: scala.collection.mutable.HashMap[String,Int] = Map(珠海 -> 3333, 广州 -> 3, 深圳 -> 33333)

如上，当我们使用remove函数去删除键值对的时候就会发现它会将值返回来，不得不说挺人性化的。

3，使用+=函数添加多个元素

上面我们知道了put函数，并用它来为hashmap可变映射添加了键值对，但是它也有局限性，一次性只能够加入一对键值对，但是如果使用+=函数的话一次性可以加入多个键值对：


scala> ma_hash1 +=("广州" ->3)
res32: ma_hash1.type = Map(上海 -> 11000, 广州 -> 3)

scala> ma_hash1 +=(("深圳" -> 33333),"珠海" -> 3333)
res33: ma_hash1.type = Map(上海 -> 11000, 珠海 -> 3333, 广州 -> 3, 深圳 -> 33333)

但是当我们使用了put函数的时候就不能够像+=函数这样一次性可以添加多个键值对，如下就会报错：

4，使用-=函数删除多个元素

和+=函数的使用一样，也可以一次性对多个元素进行操作，只需要传入key键即可：

scala> ma_hash1
res37: scala.collection.mutable.HashMap[String,Int] = Map(珠海 -> 3333, 广州 -> 3, 深圳 -> 33333)

scala> ma_hash1 -=("广州","珠海")
res38: ma_hash1.type = Map(深圳 -> 33333)

六，映射的遍历

1，获取映射中的key 【keySet函数/keys函数】

不管是列表还是数组的遍历都离不开for循环，我们的映射也不例外，只是我们在遍历映射的时候并不是通过下标遍历，而是使用keySet方法来获取映射对应的key键，之后我们再使用得到的key去访问value值，如下：

scala> map_hash
res47: scala.collection.mutable.HashMap[String,String] = Map(上海 -> 11k, 北京 -> 10k, 广州 -> 12k)


scala> for(k <- map_hash.keySet)println(s"key:${k},value:${map_hash(k)}") // 遍历map映射
key:上海,value:11k
key:北京,value:10k
key:广州,value:12k

scala> for(key <- map_hash.keys)println(s"key:${key},value:${map_hash(key)}")  // 使用keys方法
key:上海,value:11k
key:北京,value:10k
key:广州,value:12k

从上面我们可以看到keySet和keys函数都是一样的，用于获取映射中的key键。

2，获取映射中的键值对【不使用函数】

如果不想要像上面那样只想要直接一次性获取到key，而是key和value都想要同时遍历到的话可以让两个变量来存储映射中的键值对即可，如下：

scala> for((key,value) <- map_hash)println(s"key:${key},value:${value}")  // 不使用函数
key:上海,value:11k
key:北京,value:10k
key:广州,value:12k

3，获取映射中的value值【values函数】

如果只想要获取映射中的value值的话可以直接使用values函数得到，如下：

scala> for(value <- map_hash.values)println(s"value:${value}")
value:11k
value:10k
value:12k

scala> map_hash
res60: scala.collection.mutable.HashMap[String,String] = Map(上海 -> 11k, 北京 -> 10k, 广州 -> 12k)

七，将对偶的序列转换成map映射【toMap函数】

1，将含有对偶元组的数组转换成映射

对偶数组的形成有两种，一种是自己声明定义出来的，另外一种就是两个数组就行zip拉链形成。现在我们先使用两个数组进行zip拉链形成对偶数组，并使用toMap函数转换成map映射：

scala> val arr_im=Array(1,2,3)  //  静态声明不可变数组
arr_im: Array[Int] = Array(1, 2, 3)

scala> val arr_im1=Array(5,6,7)
arr_im1: Array[Int] = Array(5, 6, 7)

scala> val  zip_arrT=arr_im zip arr_im1   // 使用zip函数将两个数组进行拉链，形成对偶数组
zip_arrT: Array[(Int, Int)] = Array((1,5), (2,6), (3,7))

scala> zip_arrT.toMap     // 将对偶数组转换成map映射
res61: scala.collection.immutable.Map[Int,Int] = Map(1 -> 5, 2 -> 6, 3 -> 7)

直接声明定义一个对偶数组，并使用toMap函数转换成map映射：

scala> val t_arr= Array((1,5), (2,6), (3,7))  // 声明定义一个对偶数组数据
t_arr: Array[(Int, Int)] = Array((1,5), (2,6), (3,7))

scala> t_arr.toMap  // 使用toMap函数将对偶数组转换成map映射
res63: scala.collection.immutable.Map[Int,Int] = Map(1 -> 5, 2 -> 6, 3 -> 7)

2，将含有对偶元组的列表转换成map映射


scala> val list=List(("a",1),("b",1))  // 对偶列表
list: List[(String, Int)] = List((a,1), (b,1))

scala> list.toMap
res62: scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 1)