2 scala集合-元组和列表

1 元组

元组也是可以存放不同数据类型的元素,并且最重要的是,元组中的元素是不可变的。

例如,定义一个元组,包含字符串 hello,数字 20。如果试图把数字 20 修改为 1,则会报错。

scala 复制代码
scala> var a = ("hello", 20)
var a: (String, Int) = (hello,20)

scala> a._1
val res3: String = hello

scala> a._2 = 1
-- [E052] Type Error: ----------------------------------------------------------
1 |a._2 = 1
  |^^^^^^^^
  |Reassignment to val _2
  |
  | longer explanation available when compiling with `-explain`
1 error found

1.1 定义元组

定义元素有两种方法:

  • 使用 () 定义
  • 使用 -> 定义,这种方法定义的元组,最多只能包含2个元素。
scala 复制代码
scala> val a = (20, "Hello World", true)
val a: (Int, String, Boolean) = (20,Hello World,true)

scala> val a = 1->2
val a: (Int, Int) = (1,2)

scala> val a = 1->2,3->4
-- Error: ----------------------------------------------------------------------
1 |val a = 1->2,3->4
  |            ^
  |            end of statement expected but ',' found

1.2 访问元组

访问元组和访问数组不同,访问元组需要使用 ._index,注意,index 是从 1 开始的。

例如,._1 访问元组的第一个元素,使用 ._2 访问的是元组的第二个元素。

scala 复制代码
scala> val a = (1, "Hello World", true)
val a: (Int, String, Boolean) = (1,Hello World,true)

scala> a._1
val res4: Int = 1

scala> a._2
val res5: String = Hello World

scala> a._3
val res6: Boolean = true

2 列表

列表是 scala 中常用的数据结构,特点是可以保存重复的值,并且有先后顺序。列表和数组一样,分为可变和不可变两种。

在使用可变列表前,需要先引入类 scala.collection.mutable.ListBuffer

2.1 不可变列表

不可变列表的元素和长度都不能更改。

创建不可变列表有如下方法:

scala 复制代码
val/var variable_name = List(ele1,ele2,ele3,...)		// 创建带有初始化元素的不可变列表
val/var variable_name = ele1 :: ele2 :: Nil				// 创建带有初始化元素的不可变列表
val/var variable_name = Nil								// 创建一个空的不可变列表

根据上述3种创建方式,创建一个与萨努为 0、1、2、3 的列表:

scala 复制代码
scala> val list = List(0,1,2,3)
val list: List[Int] = List(0, 1, 2, 3)

scala> val list = 0::1::2::3::Nil
val list: List[Int] = List(0, 1, 2, 3)

scala> val list = Nil
val list: scala.collection.immutable.Nil.type = List()

2.2 可变列表

可变列表的元素和长度都是可以改变的,创建可变列表的语法如下:

scala 复制代码
// 创建空的可变列表
val/var variable_name = ListBuffer[Int]()
// 创建带有初始元素的可变列表
val/var variable_name = ListBuffer(ele1, ele2, ele3, ...)

创建一个元素为 0、1、2、3 的可变列表

scala 复制代码
scala> import scala.collection.mutable.ListBuffer

scala> val list = ListBuffer()
val list: scala.collection.mutable.ListBuffer[Nothing] = ListBuffer()

scala> val list2 = ListBuffer(0,1,2,3)
val list2: scala.collection.mutable.ListBuffer[Int] = ListBuffer(0, 1, 2, 3)

2.2.1 添加一个元素到尾部

使用运算符 += 往可变列表尾部追加一个元素。

下面定义一个可变列表,初始元素为 0、1、2、3,添加一个元素 4 到尾部。

scala 复制代码
scala> import scala.collection.mutable.ListBuffer

scala> val list = ListBuffer(0,1,2,3)
val list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(0, 1, 2, 3)

scala> list += 4
val res7: scala.collection.mutable.ListBuffer[Int] = ListBuffer(0, 1, 2, 3, 4)

2.2.2 删除一个元素

使用运算符 -= ,删除可变列表中的一个元素。

下面定义一个可变列表,初始元素为0、1、2、3,删除元素2。

scala 复制代码
scala> import scala.collection.mutable.ListBuffer

scala> val list = ListBuffer(0,1,2,3)
val list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(0, 1, 2, 3)

scala> list -= 2
val res8: scala.collection.mutable.ListBuffer[Int] = ListBuffer(0, 1, 3)

2.2.3 追加一个列表

使用运算符 ++= 往可变列表中追加另外一个列表的所有元素.

scala 复制代码
scala> val list = ListBuffer(0,1,2,3)
val list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(0, 1, 2, 3)

scala> list ++= List(4,5)
val res9: scala.collection.mutable.ListBuffer[Int] = ListBuffer(0, 1, 2, 3, 4, 5)

2.2.4 转为不可变列表

使用 toList 方法,可以把可变列表转换为不可变列表:

scala 复制代码
scala> import scala.collection.mutable.ListBuffer

scala> val list = ListBuffer(0,1,2,3)
val list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(0, 1, 2, 3)

scala> list.toList
val res10: List[Int] = List(0, 1, 2, 3)

2.2.5 转为不可变数组

使用 toArray 方法,可以把可变列表转换为不可变列表:

scala 复制代码
scala> import scala.collection.mutable.ListBuffer

scala> val list = ListBuffer(0,1,2,3)
val list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(0, 1, 2, 3)

scala> list.toArray
val res11: Array[Int] = Array(0, 1, 2, 3)

2.3 列表常用操作

2.3.1 判断列表是否为空

使用 isEmpty 方法可以判断列表是否为空:

scala 复制代码
scala> val list = List(0,1,2,3)
val list: List[Int] = List(0, 1, 2, 3)

scala> list.isEmpty
val res12: Boolean = false

2.3.2 拼接两个列表

使用运算符 ++ ,可以拼接两个列表,返回一个新生成的列表。

scala 复制代码
scala> val list = List(0,1,2,3)
val list: List[Int] = List(0, 1, 2, 3)

scala> val tempList = List(4,5)
val tempList: List[Int] = List(4, 5)

scala> list++tempList
val res13: List[Int] = List(0, 1, 2, 3, 4, 5)

2.3.3 获取首个元素及剩余部分

使用 head 可以获取列表的首个元素,而 tail 则可以获取除第一个元素外的其他元素,返回的是一个在内存中生成的新列表。

scala 复制代码
scala> val list = List(0,1,2,3)
val list: List[Int] = List(0, 1, 2, 3)

scala> list.head
val res14: Int = 0

scala> list.tail
val res15: List[Int] = List(1, 2, 3)

2.2.4 反转列表

使用 reverse 方法可以反转列表。

scala 复制代码
scala> val list = List(0,1,2,3)
val list: List[Int] = List(0, 1, 2, 3)

scala> list.reverse
val res16: List[Int] = List(3, 2, 1, 0)

2.2.5 获取列表前缀和后缀

使用 take 方法可以获取前几个元素,而 drop 方法获取第几个元素后的元素。

scala 复制代码
scala> val list = List(0,1,2,3)
val list: List[Int] = List(0, 1, 2, 3)

scala> list.take(3)
val res18: List[Int] = List(0, 1, 2)

scala> list.drop(3)
val res19: List[Int] = List(3)

2.2.6 扁平化

扁平化适用于一个列表中包含多个列表的场景。使用 flatten 方法,可以将某个列表中包含的列表元素提取出来放在另一个列表中,如果列表中有相同的元素,会保留。

scala 复制代码
scala> val list = List(List(0), List(2,3), List(1), List(0))
val list: List[List[Int]] = List(List(0), List(2, 3), List(1), List(0))

scala> list.flatten
val res21: List[Int] = List(0, 2, 3, 1, 0)

2.2.7 拉链

拉链是指,将两个列表通过相同的索引组成一个元素为元素的列表。

scala 复制代码
scala> val studentName = List("student1", "student2", "student3")
val studentName: List[String] = List(student1, student2, student3)

scala> val studentClass = List("class1", "class2", "class3", "class4")
val studentClass: List[String] = List(class1, class2, class3, class4)

scala> studentName.zip(studentClass)
val res22: List[(String, String)] = List((student1,class1), (student2,class2), (student3,class3))

2.2.8 拉开

拉开就是讲一个拉链的列表拉开,生成包含对应列表元素的元组。

scala 复制代码
scala> val studentName = List("student1", "student2", "student3")
val studentName: List[String] = List(student1, student2, student3)

scala> val studentClass = List("class1", "class2", "class3", "class4")
val studentClass: List[String] = List(class1, class2, class3, class4)

scala> val zipList = studentName.zip(studentClass)
val zipList: List[(String, String)] = List((student1,class1), (student2,class2), (student3,class3))

scala> zipList.unzip
val res23: (List[String], List[String]) = (List(student1, student2, student3),List(class1, class2, class3))

2.2.9 连接成字符串

使用 mkString,可以通过分隔符把列表的元素转换字符串。

scala 复制代码
scala> val list = List(0,1,2,3)
val list: List[Int] = List(0, 1, 2, 3)

scala> list.mkString(",")
val res24: String = 0,1,2,3

2.2.1 求并集

使用 union 方法可以取两个集合的并集,不去重。如果需要去重,则需要调用 distinct

scala 复制代码
scala> val list1 = List(0,1,2,3)
val list1: List[Int] = List(0, 1, 2, 3)

scala> val list2 = List(2,4,5,6)
val list2: List[Int] = List(2, 4, 5, 6)

scala> val unionList = list1.union(list2)
val unionList: List[Int] = List(0, 1, 2, 3, 2, 4, 5, 6)

scala> unionList.distinct
val res25: List[Int] = List(0, 1, 2, 3, 4, 5, 6)

2.2.2 求交集

使用 intersect 放可取两个列表的交集。

scala 复制代码
scala> val list1 = List(0,1,2,3)
val list1: List[Int] = List(0, 1, 2, 3)

scala> val list2 = List(2,4,5,6,3)
val list2: List[Int] = List(2, 4, 5, 6, 3)

scala> list1.intersect(list2)
val res26: List[Int] = List(2, 3)

2.2.3 求差集

使用 diff 方法,可以求两个列表的差集,例如 list1.diff(list2) 表示取 list1 中 list2 中不包含的元素

scala 复制代码
scala> val list1 = List(0,1,2,3)
val list1: List[Int] = List(0, 1, 2, 3)

scala> val list2 = List(2,4,5,6,3)
val list2: List[Int] = List(2, 4, 5, 6, 3)

scala> list1.diff(list2)
val res27: List[Int] = List(0, 1)
相关推荐
hopetomorrow14 分钟前
学习路之PHP--使用GROUP BY 发生错误 SELECT list is not in GROUP BY clause .......... 解决
开发语言·学习·php
系统之家装机大师19 分钟前
Win11 22H2/23H2系统11月可选更新KB5046732发布!
windows·电脑
系统之家装机大师21 分钟前
微软发布Win11 24H2系统11月可选更新KB5046740!
windows·电脑
小牛itbull23 分钟前
ReactPress vs VuePress vs WordPress
开发语言·javascript·reactpress
请叫我欧皇i32 分钟前
html本地离线引入vant和vue2(详细步骤)
开发语言·前端·javascript
闲暇部落35 分钟前
‌Kotlin中的?.和!!主要区别
android·开发语言·kotlin
GIS瞧葩菜44 分钟前
局部修改3dtiles子模型的位置。
开发语言·javascript·ecmascript
chnming19871 小时前
STL关联式容器之set
开发语言·c++
熬夜学编程的小王1 小时前
【C++篇】深度解析 C++ List 容器:底层设计与实现揭秘
开发语言·数据结构·c++·stl·list
GIS 数据栈1 小时前
每日一书 《基于ArcGIS的Python编程秘笈》
开发语言·python·arcgis