2 scala集合-元组和列表

1 元组

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

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

scala> var a = ("hello", 20)
var a: (String, Int) = (hello,20)scala> a._1
val res3: String = helloscala> 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> 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> val a = (1, "Hello World", true)
val a: (Int, String, Boolean) = (1,Hello World,true)scala> a._1
val res4: Int = 1scala> a._2
val res5: String = Hello Worldscala> a._3
val res6: Boolean = true

2 列表

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

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

2.1 不可变列表

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

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

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> 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 可变列表

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

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

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

scala> import scala.collection.mutable.ListBufferscala> 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> import scala.collection.mutable.ListBufferscala> 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> import scala.collection.mutable.ListBufferscala> 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> 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> import scala.collection.mutable.ListBufferscala> 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> import scala.collection.mutable.ListBufferscala> 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> 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> 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> val list = List(0,1,2,3)
val list: List[Int] = List(0, 1, 2, 3)scala> list.head
val res14: Int = 0scala> list.tail
val res15: List[Int] = List(1, 2, 3)

2.2.4 反转列表

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

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> 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> 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> 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> 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> 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> 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> 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> 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)