【Scala】关于集合的各种知识点

601-赵同学

发表文章数:191

热门标签

,
首页 » 大数据 » 正文


映射Map

Map可以分为可变Map和不可变Map,默认情况是不可变Map。两者之间的定义格式完全相同,区别在于导包
 

不可变Map

概述

有两种定义格式:
1.val m1 = Map(k1 -> v1,k2 -> v2,k3 -> v3)
2.val m2 = Map((k1 , v1),(k2 , v2),(k3 , v3))

可以进行的操作:
1.获取值 —— m1(k1) = v1 / m1.get(k1) = v1 / m1.getOrElse(k1,默认值) (最后一种比较推荐,如果查询的key有value,就输出value,如果没有,则输出给定的默认值)
2.查看指定的key是否存在 —— m1.key(k1) 输出结果为布尔类型,存在则为true,不存在则为false
3.查看Map集合中所有的key —— m1.keys

操作实例

//两种定义格式
scala> val m1 = Map("name" -> "zhangsan","age" -> 20,"sex" -> "女")
m1: scala.collection.immutable.Map[String,Any] = Map(name -> zhangsan, age -> 20, sex ->)

scala> val m2 = Map(("name","haha"),("age",18),("sex","男"))
m2: scala.collection.immutable.Map[String,Any] = Map(name -> haha, age -> 18, sex ->)

//value查询
scala> m1("name")
res9: Any = zhangsan

scala> m1.get("age")
res10: Option[Any] = Some(20)

scala> m1.getOrElse("sex","男")
res12: Any =//key查询
scala> m1.keySet("name")
res13: Boolean = true

scala> m1.keySet("height")
res15: Boolean = false

scala> m1.keys
res18: Iterable[String] = Set(name, age, sex)

 

可变Map

概述

首先要手动导包 —— import scala.collection.mutable.Map
剩下定义格式和查看操作与不可变Map一样

多于可变Map的操作:
修改value —— m1(k1) = 新的value
增加元素 —— m1 += (k3 -> v3) / m1 += ((k3 , v3)) (和定义格式一样有两种)
删除元素 —— m1 -= (k1) / m1.remove(k1)

操作实例

scala> val m2 = Map(("name","haha"),("age",18),("sex","男"))
m2: scala.collection.mutable.Map[String,Any] = Map(age -> 18, name -> haha, sex ->)

//修改value
scala> m2("name")="alias"

scala> m2("name")
res24: Any = alias

//增加元素
scala> m2 += ("height" -> 180.5)
res25: m2.type = Map(age -> 18, name -> alias, height -> 180.5, sex ->)

scala> m2 += (("city","beijing"))
res26: m2.type = Map(city -> beijing, age -> 18, name -> alias, height -> 180.5, sex ->)

//删除元素
scala> m2 -= ("height")
res27: m2.type = Map(city -> beijing, age -> 18, name -> alias, sex ->)

scala> m2.remove("city")
res28: Option[Any] = Some(beijing)

 

Map的遍历

遍历方法有两种:for循环遍历模式匹配遍历
 

for循环遍历

格式

for(i <- m1.keys) println (m1(i))

操作实例
scala> for(i <- m1.keys) println(m1(i))
zhangsan
20

 

模式匹配遍历

格式

for((x,y) <- m1) println(x+"——"+y)

操作实例
scala> for((x,y) <- m1) println(x+"——"+y)
name——zhangsan
age——20
sex——女

Tuple 元祖

概述

()括起来的,不同类型数据的聚集称为元祖。
当元祖中只有两个元素时,就和Map极其相似,称为对偶元祖
元祖中的元素值无法修改

定义格式

//第一种格式
val t1 = (元素1,元素2,元素3,...)

//第二种格式
scala内置了22个TupleN对象,需要时可以直接new Tuple来创建元祖
scala> val t2 = new Tuple
Tuple1   Tuple10   Tuple11   Tuple12   Tuple13   Tuple14   Tuple15   Tuple16   Tuple17   Tuple18   Tuple19
Tuple2   Tuple20   Tuple21   Tuple22   Tuple3   Tuple4   Tuple5   Tuple6   Tuple7   Tuple8   Tuple9

val t2 = new Tuple3(元素1,元素2,元素3)


//显而易见,第一种格式更为简便,一般情况下都是用第一种格式

获取元素方法

scala> t1._
_1   _2   _3   _4

想要获取元素时,用_1,_2,_3,...即可

元祖遍历

t1.productIterator()	//该方法会返回一个迭代器
t1.producrIterator.foreach(println(_))		//遍历格式

操作实例

//创建元祖
scala> val t1 = (123,"hello",true,3.14)
t1: (Int, String, Boolean, Double) = (123,hello,true,3.14)

scala> val t2 = new Tuple4(456,"AMDyes","false",7.777)
t2: (Int, String, String, Double) = (456,AMDyes,false,7.777)

//获取元素
scala> t1._2
res32: String = hello

scala> t2._2
res33: String = AMDyes

//元祖遍历(看着是两种形式,其实是一种方法,第一种更简便)
scala> t1.productIterator.foreach(println(_))
123
hello
true
3.14

scala> t2.productIterator.foreach(i => println(i))
456
AMDyes
false
7.777

List 列表

List分为可变List不可变List,默认情况是不可变List,区别不仅仅在于导包。
 

不可变List

概述

格式 —— val l1 = List(元素1,元素2,...)

相关方法

l1.head —— 返回集合的第一个元素
l1.tail —— 返回除了第一个元素外,其他元素组成的集合
val l1 = Nil —— Nil表示的是一个空集合,List()

相关操作

10 +: l1 —— 在集合头部添加元素
10 :: l1 —— 在集合头部添加元素
l1 :+ 10 —— 在集合尾部添加元素

操作实例

//创建List
scala> val l1 = List(12,34,56,78)
l1: List[Int] = List(12, 34, 56, 78)

//返回集合第一个元素
scala> l1.head
res38: Int = 12

//返回集合除了第一个元素的其他元素组成的集合
scala> l1.tail
res40: List[Int] = List(34, 56, 78)

//在集合头部添加元素
scala> 10 +: l1
res41: List[Int] = List(10, 12, 34, 56, 78)
//相当于l1调用了+:方法,10是参数
scala> l1.+:(10)
res42: List[Int] = List(10, 12, 34, 56, 78)
//因为l1为不可变List,所以+:的操作并没有修改l1,而是形成了一个新的集合
scala> l1
res43: List[Int] = List(12, 34, 56, 78)

scala> val l2 = 10 +: l1
l2: List[Int] = List(10, 12, 34, 56, 78)

scala> l2
res44: List[Int] = List(10, 12, 34, 56, 78)

//同样是在头部添加一个元素,和+:一样
scala> 10 :: l1
res45: List[Int] = List(10, 12, 34, 56, 78)

//在尾部添加一个元素
scala> l1 :+ 10
res46: List[Int] = List(12, 34, 56, 78, 10)

 

可变List

概述

第一步要先导包:import scala.collection.mutable.ListBuffer
格式 —— val l2 = ListBuffer[元素类型](元素1,元素2,...)

相关方法

和不可变List相同

相关操作

上述不可变List的操作同样可以使用在可变List
l2.append(元素值) —— 增加元素
l2 += 元素值 —— 增加元素
l2.remove(元素索引) —— 删除元素
l2 -= 元素值 —— 删除元素

操作实例

//导包
scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer
//创建可变List
scala> val l2 = ListBuffer[Int](11,22,33,44)
l2: scala.collection.mutable.ListBuffer[Int] = ListBuffer(11, 22, 33, 44)

//增加元素
scala> l2 += 10
res51: l2.type = ListBuffer(11, 22, 33, 44, 10)

scala> l2.append(20)
//因为是可变List,所以增加元素的操作是改变了l2的元素值
scala> l2
res53: scala.collection.mutable.ListBuffer[Int] = ListBuffer(11, 22, 33, 44, 10, 20)

//删除元素
scala> l2 -= 20
res54: l2.type = ListBuffer(11, 22, 33, 44, 10)

scala> l2.remove(4)
res55: Int = 10

scala> l2
res56: scala.collection.mutable.ListBuffer[Int] = ListBuffer(11, 22, 33, 44)

Set 集合

Set集合也分为可变Set不可变Set,默认为不可变Set,创建使用可变Set要导包
可变Set和不可变Set的格式、特点都相同,差别只在于可变与否
 

格式

val s1 = Set(元素1,元素2,...)

特点

1.元素不重复,即使创建时输入相同的元素,scala也会进行一个去重的操作
2.元素无序,也即没有了索引的概念

相关操作

只对可变Set可用:
增加元素 —— s1 += 元素值 / s1.add(元素值)
删除元素 —— s1 -= 元素值 / s1.remove(元素值)(因为Set没有索引,所以此处的remove方法和其他集合不同,只能填入元素值)

操作实例

//既体现了元素的不重复特点,又体现了元素的无序性
scala> val s1 = Set(1,1,2,2,4,4,6,6,6,7)
s1: scala.collection.immutable.Set[Int] = Set(1, 6, 2, 7, 4)

//是集合,所以查看集合长度,求和,求最大最小值的方法都可以
scala> s1.size
res57: Int = 5

scala> s1.sum
res58: Int = 20

scala> s1.min
res59: Int = 1

/**
 *两个集合求交集、并集、差集
 **/
//两个Set集合如下
scala> s1
res60: scala.collection.immutable.Set[Int] = Set(1, 6, 2, 7, 4)

scala> s2
res61: scala.collection.immutable.Set[Int] = Set(2, 7, 3, 8, 4)
//交集
scala> s1.&(s2)
res62: scala.collection.immutable.Set[Int] = Set(2, 7, 4)

scala> s1 & s2
res63: scala.collection.immutable.Set[Int] = Set(2, 7, 4)
//并集
scala> s1.++(s2)
res67: scala.collection.immutable.Set[Int] = Set(1, 6, 2, 7, 3, 8, 4)

scala> s1 ++ s2
res65: scala.collection.immutable.Set[Int] = Set(1, 6, 2, 7, 3, 8, 4)
//差集
scala> s1.--(s2)
res68: scala.collection.immutable.Set[Int] = Set(1, 6)

scala> s1 -- s2
res69: scala.collection.immutable.Set[Int] = Set(1, 6)

scala> s2 -- s1
res70: scala.collection.immutable.Set[Int] = Set(3, 8)

scala> s2.diff(s1)
res71: scala.collection.immutable.Set[Int] = Set(3, 8)

未经允许不得转载:作者:601-赵同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《【Scala】关于集合的各种知识点》 发布于2020-04-09

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录