Scala中的集合之数组丶元组丶列表

对于Scala中的集合:

集合A，元素b，集合B

1. A+b，代表新生成一个集合，新集合添加了元素，原集合A内容没变。
2. A-b，同上，代表删除元素
3. A+=b，表示集合A本身中添加元素
4. A-=b，表示A本身中删除元素
5. A++B，得到新集合，新集合包含A的所有元素和B的所有元素。原集合A内容没变。
6. A–B，得到新集合，新集合有A的元素，又要剔除掉B中有的元素。
7. A++=B，将B的所有元素追加到A中。
8. A–=B, 从A中剔除掉B中有的元素。

1. 数组

• 定长数组

1-长度不可以改变
2-元素可以改变

语法
// 通过指定长度定义数组
val/var 变量名 = new Array[元素类型](数组长度)
​
// 用元素直接初始化数组
val/var 变量名 = Array(元素1, 元素2, 元素3...)

• 变长数组

语法
1) 创建空的ArrayBuffer变长数组，语法结构：
val/var a = ArrayBuffer[元素类型]()

2) 创建带有初始元素的ArrayBuffer
val/var a = ArrayBuffer(元素1，元素2，元素3....)

使用+=添加元素
使用-=删除元素
使用++=追加一个数组到变长数组

案例: 
// 定义变长数组
scala> val a = ArrayBuffer("hadoop", "spark", "flink")
a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, spark, flink)
​
// 追加一个元素
scala> a += "flume"
res10: a.type = ArrayBuffer(hadoop, spark, flink, flume)
​
// 删除一个元素
scala> a -= "hadoop"
res11: a.type = ArrayBuffer(spark, flink, flume)
​
// 追加一个数组
scala> a ++= Array("hive", "sqoop")
res12: a.type = ArrayBuffer(spark, flink, flume, hive, sqoop)

• 遍历数组

scala> val a = Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
​
scala> for(i <- 0 to a.length - 1) println(a(i))
1
2
3
4
5
​
scala> for(i <- 0 until a.length) println(a(i))
1
2
3
4
5

• 数组常用算法

1) 最大值
2)最小值
3)求和
4)排序
scala> val a = ArrayBuffer(1,2,3,4,18000)
a: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 18000)

scala> a.min
res1: Int = 1

scala> a.sum
res2: Int = 18010

scala> a.sorted
res3: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 18000)

scala> a.max
res4: Int = 18000

scala>

2.元组

• 元组可以用来包含一组不同类型的值。例如：姓名，年龄，性别，出生年月。元组的元素是不可变的。

语法
使用括号来定义元组
val/var 元组 = (元素1, 元素2, 元素3....)

使用箭头来定义元组（只支持元组只有两个元素时）
val/var 元组 = 元素1->元素2

定义: 
1) 
scala> val a = ("liuafu","kobe","James",2021)
a: (String, String, String, Int) = (liuafu,kobe,James,2021)

2)
scala> val a = ("kobe"->41)
a: (String, Int) = (kobe,41)

访问: 
1)
访问第一个元素: 
scala> a._1
res6: String = kobe

访问第二个元素: 
scala> a._2
res7: Int = 41

3.列表

• 列表是scala中最重要的、也是最常用的数据结构. 相当于Java中的list
• 重复 有序

不可变列表:

定义:列表的元素、长度都是不可变的。

语法:
1) 使用List(元素1, 元素2, 元素3, ...)来创建一个不可变列表，语法格式：
val/var 变量名 = List(元素1, 元素2, 元素3...)   //最常用

2) 使用Nil创建一个不可变的空列表
val/var 变量名 = Nil

3) 使用::方法创建一个不可变列表
val/var 变量名 = 元素1 :: 元素2 :: Nil

例如: 
scala> val a = List(18000,20000,22000)
a: List[Int] = List(18000, 20000, 22000)

可变列表:

定义: 列表的元素、长度都是可变的。

语法:
使用ListBuffer[元素类型]()创建空的可变列表，语法结构：
val/var 变量名 = ListBuffer[T]()

使用ListBuffer(元素1, 元素2, 元素3...)创建可变列表，语法结构：
val/var 变量名 = ListBuffer(元素1，元素2，元素3...)

操作可变列表:

1. 获取元素（使用括号访问(索引值)）
2. 添加元素（+=）
3. 追加一个列表（++=）
4. 更改元素（使用括号获取元素，然后进行赋值）
5. 删除元素（-=）
6. 转换为List（toList）
7. 转换为Array（toArray）

//创建一个可变列表
scala> val a = ListBuffer(1,2,3)
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)

//获取列表的第一个元素
scala> a(0)
res8: Int = 1

//添加元素
scala> a +=4
res9: a.type = ListBuffer(1, 2, 3, 4)

//添加一个列表
scala> a ++=List(18000,20000,22000)
res10: a.type = ListBuffer(1, 2, 3, 4, 18000, 20000, 22000)

//删除一个元素
scala> a -=1
res11: a.type = ListBuffer(2, 3, 4, 18000, 20000, 22000)

//转为一个数组
scala> a.toArray
res12: Array[Int] = Array(2, 3, 4, 18000, 20000, 22000)

//转为一个不可变的列表
scala> a.toList
res13: List[Int] = List(2, 3, 4, 18000, 20000, 22000)

• 列表的常用操作

1. 判断列表是否为空（isEmpty）
2. 拼接两个列表（++）
3. 获取列表的首个元素（head）和剩余部分(tail)
4. 反转列表（reverse）
5. 获取前缀（take）、获取后缀（drop）
6. 扁平化（flaten）
7. 拉链（zip）和拉开（unzip）
8. 转换字符串（toString）
9. 生成字符串（mkString）
10. 并集（union）
11. 交集（intersect）
12. 差集（diff）

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

//判断是否为空
scala> a.isEmpty
res14: Boolean = false

//拼接两个列表
scala> val b = List(18000,20000,22000)
b: List[Int] = List(18000, 20000, 22000)

scala> a ++ b
res16: List[Int] = List(1, 2, 3, 4, 18000, 20000, 22000)

//反转
scala> b.reverse
res17: List[Int] = List(22000, 20000, 18000)

//拉链 
scala> val a = List("zhangsan", "lisi", "wangwu")
a: List[String] = List(zhangsan, lisi, wangwu)
​
scala> val b = List(19, 20, 21)
b: List[Int] = List(19, 20, 21)
​
scala> a.zip(b)
res1: List[(String, Int)] = List((zhangsan,19), (lisi,20), (wangwu,21))

//拉开
scala> res1.unzip
res2: (List[String], List[Int]) = (List(zhangsan, lisi, wangwu),List(19, 20, 21))

//扁平化: 扁平化表示将列表中的列表中的所有元素放到一个列表中。

例子:
scala> val a =List(List(12,15),List(25,30),List(55,20))
a: List[List[Int]] = List(List(12, 15), List(25, 30), List(55, 20))

scala> a.flatten
res18: List[Int] = List(12, 15, 25, 30, 55, 20)