2 scala集合-元组和列表
1 元组
元组也是可以存放不同数据类型的元素，并且最重要的是，元组中的元素是不可变的。
例如，定义一个元组，包含字符串 hello，数字 20。如果试图把数字 20 修改为 1，则会报错。
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> 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 = 1
scala> a._2
val res5: String = Hello World
scala> 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.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> 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> 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> 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.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> 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> 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 = 0
scala> 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)