1.22

数据结构
数组
定长数组
语法：

val/var 变量名 = new Array[元素类型](数组长度)
val/var 变量名 = new Array(元素1, 元素2 ...)

示例：

def main(args: Array[String]): Unit = {
val arr = new Array[Int](10)
arr(0) = 1
println(arr(0))//1
println(arr.length)//10
}

变长数组
语法：

val/var 变量名 = ArrayBuffer[元素类型]
val/var 变量名 = ArrayBuffer(元素1, 元素2 ...)

示例：

def main(args: Array[String]): Unit = {
val arr = ArrayBuffer[Int]()
val arr1 = ArrayBuffer("1", true, 3)
println(arr)//ArrayBuffer()
println(arr1)//ArrayBuffer(1, true, 3)
}

增删改：

使用 += 添加单个元素
使用 -= 删除单个元素
使用 ++= 追加一个数组
使用 --= 移除多个元素
示例：

def main(args: Array[String]): Unit = {
val arr = ArrayBuffer("spark", "hadoop", "flink")
arr += "flume"
arr -= "spark"
arr ++= Array("hive", "sqoop")
arr --= Array("sqoop", "hadoop")
println(arr)//ArrayBuffer(flink, flume, hive)
}

遍历数组
通过索引

for(i <- 0 to arr.length-1)//to包括右
println(arr(i))
for(i <- arr.indices)
println(arr(i))
for(i <- 0 until(arr.length))//until不包括右
println(arr(i))

通过 for 循环

for (elem <- arr)
println(elem)

数组常用算法
sum ：求和

max：求最大值

min：求最小值

sorted：排序，返回一个新的数组

reverse：反转，返回一个新的数组

示例：

def main(args: Array[String]): Unit = {
val arr = Array(4,1,6,5,2,3)
println(arr.sum)//21
println(arr.max)//6
println(arr.min)//1
val arr1 = arr.sorted
for (elem <- arr1)
print(elem)//123456
println()
val arr2 = arr1.reverse
for (elem <- arr2)
print(elem)//654321
}


元组
元组一般用来存储不同类型的数据，并且长度和元素都不可变。

语法：

//通过小括号实现
val/var 元组 = (元素1,元素2...)
//通过箭头(只适用于有2个元素的情况)
val/var 元组 = 元素1 -> 元素2...

示例：

def main(args: Array[String]): Unit = {
val tuple = ("sjh", 24)
val tuple1 = "sjh" -> 24
println(tuple)//(sjh,24)
println(tuple1)//(sjh,24)
}

访问元组中元素

通过 元组名._编号 形式访问元组中元素，编号从 1 开始。或者通过 元组名.productIterator 获取迭代器遍历。

示例：

def main(args: Array[String]): Unit = {
val tuple = "sjh" -> 24
//方法1 通过编号
println(tuple._1)
//方法2 获取迭代器
val iterator = tuple.productIterator
for (elem <- iterator)
println(elem)
}

列表
不可变列表
List 存储的数据有序、可重复，有序是指元素的存入和取出顺序是一致的。列表分为不可变列表和可变列表。

不可变列表指的是列表的元素、长度都不可变。

语法：

val/var 变量名 = List(元素1,元素2...)
val/var 变量名 = Nil
val/var 变量名 = 元素1 :: 元素2 :: Nil

可变列表
语法：

val/var 变量名 = ListBuffer[数据类型]()
val/var 变量名 = ListBuffer(元素1,元素2...)

可变列表常用操作：

格式 功能
列表名(索引) 根据索引获取元素
列表名(索引) = 值 修改元素值
+= 添加单个元素
++= 追加列表
-= 删除某个元素
–= 删除多个元素
toList 转为不可变列表
toArray 转为数组
示例：

def main(args: Array[String]): Unit = {
val list = ListBuffer(1, 2, 3)
println(list(0))
list += 4
list ++= List(5, 6, 7)
list -= 7
list --= List(3, 4)
val list1 = list.toList
val array = list.toArray
println(list1)//List(1, 2, 5, 6)
for (elem <- array) print(elem)//1256
}

列表常用操作
格式 功能
distinct 去重
isEmpty 判断是否为空
++ 拼接两个列表
head 返回第一个元素
tail 返回除了第一个元素之外的其他元素
reverse 反转并返回新列表
take 获取前缀元素（自定义个数）
drop 获取后缀元素（自定义个数）
flatten 扁平化操作，返回新列表
zip 拉链操作，合并列表
unzip 拉开操作，拆分列表
toString 转换默认字符串
mkString 转换指定字符串
union 获取两个列表并集元素，返回新列表
intersect 获取两个列表交集元素，返回新列表
diff 获取两个列表差集元素，返回新列表
示例：

def main(args: Array[String]): Unit = {
val list = List(1, 2, 3, 4)
print(list.isEmpty)//false
val list2 = List(4, 5, 6)
val list3 = list ++ list2
println(list3)//List(1, 2, 3, 4, 4, 5, 6)
println(list3.head)//1
println(list3.tail)//List(2, 3, 4, 4, 5, 6)
//前3个是前缀
println(list3.take(3))//List(1, 2, 3)
//前3个是前缀，获取后缀
println(list3.drop(3))//List(4, 4, 5, 6)
}
示例：扁平化操作

将嵌套列表（每个元素都是列表）的所有具体元素单独放到一个新的列表

def main(args: Array[String]): Unit = {
val list1 = List(1, 2)
val list2 = List(3, 4)
val list = List(list1, list2, List(5))
val flatten = list.flatten
println(list)//List(List(1, 2), List(3, 4), List(5))
println(flatten)//List(1, 2, 3, 4, 5)
}

示例：拉链与拉开

拉链：将两个列表组合成一个元素为元组的列表

拉开：将一个包含元组的列表，拆解成包含两个列表的元组

def main(args: Array[String]): Unit = {
val names = List("sjh", "a", "bb")
val ages = List(24, 1, 10)
val list1 = names.zip(ages)
println(list1)//List((sjh,24), (a,1), (bb,10))
val tuple1 = list1.unzip
println(tuple1)//(List(sjh, a, bb),List(24, 1, 10))
}

示例：转换字符串

mkString 以指定符号分割元素

def main(args: Array[String]): Unit = {
val list = List(1, 2, 3, 4)
println(list.toString())//List(1, 2, 3, 4)
println(list.mkString(":"))//1:2:3:4
}