1.23

集
不可变集
特点：唯一、无序

语法：

//创建空的不可变集
val/var 变量名 = Set[类型]()
//指定元素
val/var 变量名 = Set(元素1, 元素2...)

常用操作：

size 获取大小
遍历操作和数组一致
+ 添加元素，生成一个新的 Set
++ 拼接集或列表，生成一个新的 Set
- 删除一个元素，生成一个新的 Set
-- 删除多个元素，，生成一个新的 Set
可变集
导入包

import scala.collection.mutable.Set

映射
不可变 Map
语法：

//通过箭头
val/var map = Map(k1->v1, k2->v2...)
//通过小括号
val/var map = Map((k1,v1), (k2,v2)...)

可变 Map
导入包

import scala.collection.mutable.Map

基本操作：

map(key) 获取键对应值，不存在返回None
map.keys 获取所有键
map.values 获取所有值
遍历 通过普通for实现
getOrElse 根据键获取值，不存在返回指定默认值
+ 增加键值对，生成一个新的 Map。如果是可变 Map，直接使用 += 或 ++= 。
- 删除键值对，生成一个新的 Map。如果是可变 Map，直接使用 -= 或 --= 。
示例：

def main(args: Array[String]): Unit = {
val map = Map("sjh" -> 24, "ax" -> 10)
println(map.keys)//Set(ax, sjh)
println(map.values)//HashMap(10, 24)
for (elem <- map) { println(elem)}//(ax,10) (sjh,24)
println(map.getOrElse("sjh", 1))//24
map += "abc" -> 10
println(map)//Map(abc -> 10, ax -> 10, sjh -> 24)
}
迭代器
使用 iterator 从集合获取迭代器，迭代器的两个方法：

hasNext 判断是否有下一个元素

next 返回下一个元素，没有会抛出异常

示例：

def main(args: Array[String]): Unit = {
val list = List(1, 2, 3, 4, 5)
val iterator = list.iterator
while (iterator.hasNext)
print(iterator.next())//12345
}

函数式编程
函数式编程指 方法的参数列表可以接收函数对象。

函数名 功能
foreach 遍历集合
map 转换集合
flatmap 扁平化操作
sorted 默认排序
sortBy 按照指定字段排序
sortWith 自定义排序
groupBy 按指定条件分组
reduce 聚合计算
fold 折叠计算
foreach
def main(args: Array[String]): Unit = {
val list = List(1, 2, 3, 4, 5)
//函数格式 (函数参数列表) => {函数体}
list.foreach((x:Int) => {println(x)})
//简写格式1 通过类型推断省略参数数据类型
list.foreach(x => println(x))
//简写格式2 函数参数只在函数体出现一次，且函数体没有涉及复杂使用，可以使用下划线简化
list.foreach(println(_))
}

map
将一种类型转换为另一种类型，例如将 Int 列表转为 String 列表

def main(args: Array[String]): Unit = {
val list = List(1, 2, 3, 4)
//将数字转换为对应个数的 *
val list2 = list.map((x:Int) => {"*" * x})
println(list2)//List(*, **, ***, ****)
//根据类型推断简化
val list3 = list.map(x => "*" * x)
println(list3)//List(*, **, ***, ****)
//下划线
val list4 = list.map("*" * _)
println(list4)//List(*, **, ***, ****)
}

flatMap
可以理解为先进行 map ，再进行 flatten 操作。

def main(args: Array[String]): Unit = {
val list = List("hadoop hive spark flink", "kudu hbase storm")

val list2 =list.map(_.split(" ")).flatten
println(list2)//List(hadoop, hive, spark, flink, kudu, hbase, storm)

val list3 =list.flatMap(_.split(" "))
println(list2)//List(hadoop, hive, spark, flink, kudu, hbase, storm)
}

filter
过滤出符合一定条件的元素，示例，筛选偶数：

def main(args: Array[String]): Unit = {
val list = (1 to 6).toList
println(list.filter(_ % 2 == 0))//List(2, 4, 6)
}

排序
def main(args: Array[String]): Unit = {
//升序排序
val list = List(3, 1, 2, 9, 8)
println(list.sorted)//List(1, 2, 3, 8, 9)
//指定字段排序
val list2 = List("01 hadoop", "02 flume", "03 hive")
println(list2.sortBy(_.split(" ")(1)))//List(02 flume, 01 hadoop, 03 hive)
//自定义排序实现降序
val list3 = List(2, 3, 1, 6, 4, 5)
//第一个下划线表示前面的元素，第二个下划线表示后面的元素
println(list3.sortWith(_ > _))//List(6, 5, 4, 3, 2, 1)
}

group by
将数据按指定条件进行分组，示例，按照性别分组：

def main(args: Array[String]): Unit = {
val list = List("sjh"->"男","ssf"->"女","ka"->"男")
//按照元素第二个元素分组
//val map = list.groupBy(x => x._2)
val map = list.groupBy(_._2)
println(map)//Map(男 -> List((sjh,男), (ka,男)), 女 -> List((ssf,女)))
//统计不同性别人数
val map2 = map.map(x => x._1 -> x._2.length)//不能用下划线简化，因为x在后面出现了2次
println(map2)//Map(男 -> 2, 女 -> 1)
}

reduce 和 fold
示例：计算1-10的和，reduce 相当于 reduceLeft，如果想从右到左计算使用 reduceRight

def main(args: Array[String]): Unit = {
val list = (1 to 10).toList
//x表示聚合操作的结果，y表示下一个元素
var i = list.reduce((x, y) => x + y)
//简化
i = list.reduce(_ + _)
println(i)//55
}

fold 和 reduce 很像，只是 fold 多了一个指定初始化值参数

fold 相当于 foldLeft，如果想从右到左计算使用 foldRight

示例：定义一个列表包括1-10，假设初始化值100，计算所有元素和

def main(args: Array[String]): Unit = {
val list = (1 to 10).toList
//x表示聚合操作的结果，y表示下一个元素
val i = list.fold(100)(_ + _)
println(i)//155
}

案例：学生成绩单
定义列表，记录学生成绩，格式为：姓名，语文成绩，数学成绩，英语成绩。

获取所有语文成绩在60分以上得同学信息。

获取所有学生的总成绩。

按照总成绩降序排列。

def main(args: Array[String]): Unit = {
val list = List(("a", 37, 90 ,100), ("b", 90, 73 ,80), ("c", 60, 90, 76), ("d", 59, 21, 72), ("e", 100, 100, 100))
//获取语文成绩60分以上学生信息
val list1 = list.filter(_._2 > 60)
println(list1)//List((b,90,73,80), (e,100,100,100))

//获取所有学生总成绩
val list2 = list.map(x => x._1 -> (x._2 + x._3 + x._4))
println(list2)//List((a,227), (b,243), (c,226), (d,152), (e,300))

//按照总成绩降序排列
val list3 = list2.sortWith(_._2 > _._2)
println(list3)//List((e,300), (b,243), (a,227), (c,226), (d,152))

}