学习目标
-
- 遍历（foreach）
-
- 使用类型推断简化函数定义
- 使用下划线来简化函数定义
- 映射（map）
- 扁平化映射（flatMap）
- 过滤（filter）
- 排序（sort）
-
- 默认排序 | sorted
- 指定字段排序 | sortBy
- 自定义排序 | sortWith
- 分组（groupBy）
- 聚合（reduce/fold）
-
- 聚合 | reduce
- 折叠 | fold
遍历（foreach）
格式
foreach(f: (A) ⇒ Unit): Unit
说明
| foreach | API | 说明 |
|---|---|---|
| 参数 | f:(A) => Unit | 接收一个函数对象,函数的输入参数为集合的元素，返回值为空 |
| 返回值 | Unit | 空 |
foreach执行过程
示例
有一个列表，包含以下元素：1,2,3,4, 请使用foreach方法遍历打印每个元素
参考代码
// 定义一个列表
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
// 迭代打印
scala> a.foreach((x:Int)=>println(x))
执行结果
使用类型推断简化函数定义
scala可以自动来推断出来集合中每个元素参数的类型
创建函数时，可以省略其参数列表的类型
示例
1.有一个列表，包含以下元素：1,2,3,4,请使用foreach方法遍历打印每个元素
2.使用类型推断简化函数定义
参考代码
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
// 省略参数类型
scala> a.foreach(x=>println(x))
执行结果
使用下划线来简化函数定义
当函数参数，只在函数体中出现一次，且函数体没有嵌套调用时，可以使用下划线来简化函数定义
示例
1.有一个列表，包含以下元素：1,2,3,4,请使用foreach方法遍历打印每个元素
2.使用下划线简化函数定义
参考代码
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
a.foreach(println(_))
执行结果
注
如果方法参数是函数，如果出现了下划线，scala编译器会自动将代码封装到一个函数中
参数列表也是由scala编译器自动处理
映射（map）
集合的映射操作是将来在编写Spark/Flink用得最多的操作，
是我们必须要掌握的。
因为进行数据计算的时候，
就是一个将一种数据类型转换为另外一种数据类型的过程。
map方法接收一个函数，将这个函数应用到每一个元素，返回一个新的列表
格式
def map[B](f: (A) ⇒ B): TraversableOnce[B]
说明
| map方法 | API | 说明 |
|---|---|---|
| 泛型 | [B] | 指定map方法最终返回的集合泛型 |
| 参数 | f:(A) => B | 传入一个函数对象，该函数接收一个类型A（要转换的列表元素），返回值为类型B |
| 返回值 | TraversableOnec[B] | B类型的集合 |
map方法解析
案例一
1.创建一个列表，包含元素1,2,3,4
2.对List中的每一个元素加1
参考代码
scala> a.map(x=>x+1)
res5: List[Int] = List(2, 3, 4, 5)
执行结果
案例二
1.创建一个列表，包含元素1,2,3,4
2.使用下划线来定义函数，对List中的每一个元素加1
参考代码
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
scala> a.map(_ + 1)
执行结果
扁平化映射（flatMap）
定义
可以把flatMap，理解为先map，然后再flatten
注
map是将列表中的元素转换为一个List
flatten再将整个列表进行扁平化
格式
def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B]
说明
| flatmap方法 | API | 说明 |
|---|---|---|
| 泛型 | [B] | 最终要转换的集合元素类型 |
| 参数 | f: (A) ⇒ GenTraversableOnce[B] | 传入一个函数对象,函数的参数是集合的元素,函数的返回值是一个集合 |
| 返回值 | TraversableOnce[B] | B类型的集合 |
案例
案例说明
有一个包含了若干个文本行的列表：
"hadoop hive spark flink flume", "kudu hbase sqoop storm"
获取到文本行中的每一个单词，并将每一个单词都放到列表中
思路分析
步骤
1.使用map将文本行拆分成数组
2.再对数组进行扁平化
参考代码
// 定义文本行列表
scala> val a = List("hadoop hive spark flink flume", "kudu hbase sqoop storm")
a: List[String] = List(hadoop hive spark flink flume, kudu hbase sqoop storm)
// 使用map将文本行转换为单词数组,使用空格进行切分
scala> a.map(x=>x.split(" "))
res5: List[Array[String]] = List(Array(hadoop, hive, spark, flink, flume), Array(kudu, hbase, sqoop, storm))
// 扁平化，将数组中的
scala> a.map(x=>x.split(" ")).flatten
res6: List[String] = List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)
执行结果
使用flatMap简化操作
参考代码
scala> val a = List("hadoop hive spark flink flume", "kudu hbase sqoop storm")
a: List[String] = List(hadoop hive spark flink flume, kudu hbase sqoop storm)
scala> a.flatMap(_.split(" "))
res2: List[String] = List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)
执行结果
过滤（filter）
过滤符合一定条件的元素
格式
def filter(p: (A) ⇒ Boolean): TraversableOnce[A]
说明
| filter方法 | API | 说明 |
|---|---|---|
| 参数 | p: (A) ⇒ Boolean | 传入一个函数对象,接收一个集合类型的参数,返回布尔类型，满足条件返回true, 不满足返回false |
| 返回值 | TraversableOnce[A] | 列表 |
案例
1.有一个数字列表，元素为：1,2,3,4,5,6,7,8,9
2.请过滤出所有的偶数
参考代码
scala> List(1,2,3,4,5,6,7,8,9).filter(_ % 2 == 0)
res4: List[Int] = List(2, 4, 6, 8)
执行结果
排序（sort）
在scala集合中，可以使用以下几种方式来进行排序
sorted默认排序
sortBy指定字段排序
sortWith自定义排序
默认排序 | sorted
示例
1.定义一个列表，包含以下元素: 3, 1, 2, 9, 7
2.对列表进行升序排序
参考代码
scala> List(3,1,2,9,7).sorted
res0: List[Int] = List(1, 2, 3, 7, 9)
执行结果
指定字段排序 | sortBy
根据传入的函数转换后，再进行排序
格式
def sortBy[B](f: (A) ⇒ B): List[A]
说明
| sortBy方法 | API | 说明 |
|---|---|---|
| 泛型 | [B] | 按照什么类型来进行排序 |
| 参数 | f: (A) ⇒ B | 传入函数对象,接收一个集合类型的元素参数,返回B类型的元素进行排序 |
| 返回值 | List[A] | 返回排序后的列表 |
示例
1.有一个列表，分别包含几下文本行："01 hadoop", "02 flume", "03 hive", "04 spark"
2.请按照单词字母进行排序
参考代码
scala> val a = List("01 hadoop", "02 flume", "03 hive", "04 spark")
a: List[String] = List(01 hadoop, 02 flume, 03 hive, 04 spark)
// 获取单词字段
scala> a.sortBy(_.split(" ")(1))
res1: List[String] = List(02 flume, 01 hadoop, 03 hive, 04 spark)
执行结果
自定义排序 | sortWith
自定义排序，根据一个函数来进行自定义排序
格式
def sortWith(lt: (A, A) ⇒ Boolean): List[A]
说明
| sortWith方法 | API | 说明 |
|---|---|---|
| 参数 | lt: (A, A) ⇒ Boolean | 传入一个比较大小的函数对象,接收两个集合类型的元素参数,返回两个元素大小，小于返回true，大于返回false |
| 返回值 | List[A] | 返回排序后的列表 |
示例
1.有一个列表，包含以下元素：2,3,1,6,4,5
2.使用sortWith对列表进行降序排序
参考代码
scala> val a = List(2,3,1,6,4,5)
a: List[Int] = List(2, 3, 1, 6, 4, 5)
scala> a.sortWith((x,y) => if(x<y)true else false)
res2: List[Int] = List(1, 2, 3, 4, 5, 6)
scala> a.sortWith((x,y) => if(x<y)true else false).reverse
res3: List[Int] = List(6, 5, 4, 3, 2, 1)
使用下划线简写上述案例
参考代码
scala> val a = List(2,3,1,6,4,5)
a: List[Int] = List(2, 3, 1, 6, 4, 5)
// 函数参数只在函数中出现一次，可以使用下划线代替
scala> a.sortWith(_ < _).reverse
res6: List[Int] = List(6, 5, 4, 3, 2, 1)
执行结果
分组（groupBy）
如果要将数据按照分组来进行统计分析，就需要使用到分组方法
定义
groupBy表示按照函数将列表分成不同的组
格式
def groupBy[K](f: (A) ⇒ K): Map[K, List[A]]
说明
| groupBy方法 | API | 说明 |
|---|---|---|
| 泛型 | [K] | 分组字段的类型 |
| 参数 | f:(A) => K | 传入一个函数对象，接收结合元素类型的参数，返回一个K类型的key，这个key会用来进行分组，相同的key放在一组中 |
| 返回值 | Map[K,List[A]] | 返回一个映射，K为分组字段，List为这个分组字段对应的一组数据 |
groupBy执行过程分析
示例
1.有一个列表，包含了学生的姓名和性别:
"张三", "男"
"李四", "女"
"王五", "男"
2.请按照性别进行分组，统计不同性别的学生人数
步骤
1.定义一个元组列表来保存学生姓名和性别
2.按照性别进行分组
3.将分组后的Map转换为列表：List(("男" -> 2), ("女" -> 1))
参考代码
scala> val a = List("张三"->"男", "李四"->"女", "王五"->"男")
a: List[(String, String)] = List((张三,男), (李四,女), (王五,男))
// 按照性别分组
scala> a.groupBy(_._2)
res0: scala.collection.immutable.Map[String,List[(String, String)]] = Map(男 -> List((张三,男), (王五,男)),
女 -> List((李四,女)))
// 将分组后的映射转换为性别/人数元组列表
scala> res0.map(x => x._1 -> x._2.size)
res1: scala.collection.immutable.Map[String,Int] = Map(男 -> 2, 女 -> 1)
//将生成的map映射转换为列表
scala> res1.toList
res2: List[(String, Int)] = List((男,2), (女,1))
执行结果
聚合（reduce/fold）
聚合操作，可以将一个列表中的数据合并为一个。这种操作经常用来统计分析中
聚合 | reduce
reduce表示将列表，传入一个函数进行聚合计算
格式
def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
说明
| reduce方法 | API | 说明 |
|---|---|---|
| 泛型 | [A1 >: A] | (下界)A1必须是集合元素类型的子类 |
| 参数 | op:(A1,A1) =>A1 | 传入函数对象，用来不断进行聚合操作;第一个A1类型参数为：当前聚合后的变量值;第二个A1类型参数为：当前要进行聚合的元素 |
| 返回值 | A1 | 列表最终聚合为一个元素 |
reduce执行流程分析
注
reduce和reduceLeft效果一直，表示从左到右计算
reduceRight表示从右到左计算
示例
1.定义一个列表，包含以下元素：1,2,3,4,5,6,7,8,9,10
2.使用reduce计算所有元素的和
参考代码
scala> val a = List(1,2,3,4,5,6,7,8,9,10)
a: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
scala> a.reduce((x,y) => x + y)
res0: Int = 55
// 第一个下划线表示第一个参数，就是历史的聚合数据结果
// 第二个下划线表示第二个参数，就是当前要聚合的数据元素
scala> a.reduce(_ + _)
res1: Int = 55
// 与reduce一样，从左往右计算
scala> a.reduceLeft(_ + _)
res2: Int = 55
// 从右往左聚合计算
scala> a.reduceRight(_ + _)
res3: Int = 55
执行结果
最终结果
折叠 | fold
fold与reduce很像，但是多了一个指定初始值参数
格式
def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
说明
| reduce方法 | API | 说明 |
|---|---|---|
| 泛型 | [A1 >: A] | (下界)A1必须是集合元素类型的子类 |
| 参数1 | z:A1 | 初始值 |
| 参数2 | op:(A1,A1) =>A1 | 传入函数对象，用来不断进行折叠操作;第一个A1类型参数为：当前折叠后的变量值;第二个A1类型参数为：当前要进行折叠的元素 |
| 返回值 | A1 | 列表最终折叠为一个元素 |
注
fold和foldLet效果一致，表示从左往右计算
foldRight表示从右往左计算
案例
1.定义一个列表，包含以下元素：1,2,3,4,5,6,7,8,9,10
2.使用fold方法计算所有元素的和
参考代码
scala> val a = List(1,2,3,4,5,6,7,8,9,10)
a: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
scala> a.fold(0)(_ + _)
res4: Int = 55
scala> a.fold(100)(_ + _)
res5: Int = 155
执行结果