Scala--API详解

1）遍历-foreach

• 说明

  • 之前，我们学习过了使用for表达式来遍历集合。
  • 我们接下来将学习scala的函数式编程，使用foreach方法来进行遍历、迭代。它可以让代码更加简洁。

• 方法签名

  • foreach(f: (A) ⇒ Unit): Unit

foreach	API	说明
参数	f: (A) ⇒ Unit	接收一个函数对象，函数的输入参数为集合的元素，返回值为空
返回值	Unit	空

2）过滤-filter

• 说明
  • 过滤符合一定条件的元素
• 方法签名
  • def filter(p: (A) ⇒ Boolean): TraversableOnce[A]

filter方法	API	说明
参数	p: (A) ⇒ Boolean	传入一个函数对象，接收一个集合类型的参数，返回布尔类型，满足条件返回true, 不满足返回false
返回值	TraversableOnce[A]	列表

• 图解
  

3）排序-sorted-sortBy-sortWith

• 说明
  • 在scala集合中，可以使用以下几种方式来进行排序
    • sorted默认排序
    • sortBy指定字段排序
    • sortWith自定义排序

1.默认排序 | sorted

• 定义一个列表，包含以下元素: 3, 1, 2, 9, 7
• 对列表进行升序排序

List(3,1,2,9,7).sorted

2.指定字段排序 | sortBy

• 说明
  • 根据传入的函数转换后，再进行排序
• 方法签名
  • def sortBy[B](f: (A) ⇒ B): List[A]

sortBy方法	API	说明
泛型	[B]	按照什么类型来进行排序
参数	f: (A) ⇒ B	传入函数对象 接收一个集合类型的元素参数 返回B类型的元素进行排序
返回值	List[A]	返回排序后的列表

• 示例
  • 有一个列表，分别包含几下文本行：“01 hadoop”, “02 flume”, “03 hive”, “04 spark”
  • 请按照单词字母进行排序

val a = List("01 hadoop", "02 flume", "03 hive", "04 spark")
 	a.sortBy(_.split(" ")(1))//List(02 flume, 01 hadoop, 03 hive, 04 spark)

3.自定义排序 | sortWith

• 说明
  • 自定义排序，根据一个函数来进行自定义排序
• 方法签名
  • def sortWith(lt: (A, A) ⇒ Boolean): List[A]

sortWith方法	API	说明
参数	lt: (A, A) ⇒ Boolean	传入一个比较大小的函数对象，接收两个集合类型的元素参数，返回两个元素大小，小于返回true，大于返回false
返回值	List[A]	返回排序后的列表

• 示例
  • 有一个列表，包含以下元素：2,3,1,6,4,5
  • 使用sortWith对列表进行降序排序

	val a = List(2,3,1,6,4,5)
val r = a.sortWith((x,y) => if(x<y)true else false)
   ​r.reverse//List(6, 5, 4, 3, 2, 1)
    //a.sortWith(_ < _).reverse

4）映射-map

• 说明
  • 集合的映射操作是将来在编写Spark/Flink用得最多的操作，是我们必须要掌握的。因为进行数据计算的时候，就是一个将一种数据类型转换为另外一种数据类型的过程。
  • map方法接收一个函数，将这个函数应用到每一个元素，返回一个新的列表
• 方法签名
  • def map[B](f: (A) ⇒ B): TraversableOnce[B]

map方法	API	说明
泛型	[B]	指定map方法最终返回的集合泛型
参数	f: (A) ⇒ B	传入一个函数对象 该函数接收一个类型A（要转换的列表元素），返回值为类型B
返回值	TraversableOnce[B]	B类型的集合

• 图解
  

5）扁平化映射-flatMap

• 说明
  • 扁平化映射也是将来用得非常多的操作，也是必须要掌握的。
  • 可以把flatMap，理解为先map，然后再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”
  • 获取到文本行中的每一个单词，并将每一个单词都放到列表中
• 先map操作，在进行flatten压扁
  
• 参考代码

// 定义文本行列表
val a = List("hadoop hive spark flink flume", "kudu hbase sqoop storm")
// 使用map将文本行转换为单词数组
a.map(x=>x.split(" "))//List(Array(hadoop, hive, spark, flink, flume), Array(kudu, hbase, sqoop, storm))
//扁平化，将数组中的
a.map(x=>x.split(" ")).flatten//List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)

• 使用flatMap简化操作
  
• 参考代码

val a = List("hadoop hive spark flink flume", "kudu hbase sqoop storm")
a.flatMap(_.split(" "))//List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)

6）分组-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为这个分组字段对应的一组数据

• 图解
  
• 案例
  • 有一个列表，包含了学生的姓名和性别:
  • List(“张三”->“男”, “李四”->“女”, “王五”->“男”)
  • 按照性别进行分组，统计不同性别的学生人数:
  • List((“男” -> 2), (“女” -> 1))
• 参考代码

val a = List("张三"->"男", "李四"->"女", "王五"->"男")
val r1 =a.groupBy(_._2)
//Map[String,List[(String, String)]] = Map(男 -> List((张三,男), (王五,男)),女 -> List((李四,女)))
r1.map(x => x._1 -> x._2.size)
//Map[String,Int] = Map(男 -> 2, 女 -> 1)

7）规约/聚合-reduce

• 说明
  • 规约：将二元函数应用于集合中的函数/将集合，传入一个函数进行聚合计算
• 方法签名
  • def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

reduce方法	API	说明
泛型	[A1 >: A]	（下界）A1必须是集合元素类型的子类
参数	op: (A1, A1) ⇒ A1	传入函数对象，用来不断进行聚合操作，第一个A1类型参数为：当前聚合后的变量，第二个A1类型参数为：当前要进行聚合的元素
返回值	A1	列表最终聚合为一个元素

• 图解
  

reduce、reduceLeft和reduceRight

• reduce和reduceLeft效果一致，表示从左到右计算，reduceRight表示从右到左计算
• .reduceLefft(_ - _)这个函数的执行逻辑如图所示：
  • val list = List(1, 2, 3, 4, 5)
  • val i1 = list.reduceLeft(_ - _)//-13
    
  • .reduceRight(_ - _)反之同理
• 案例

val a = List(1,2,3,4,5,6,7,8,9,10)
a.reduce((x,y) => x + y)//55
// 第一个下划线表示第一个参数，就是历史的聚合数据结果
// 第二个下划线表示第二个参数，就是当前要聚合的数据元素
a.reduce(_ + _)//55
// 与reduce一样，从左往右计算
a.reduceLeft(_ + _)//55
// 从右往左聚合计算
a.reduceRight(_ + _)//55

8）折叠-fold

• fold函数将上一步返回的值作为函数的第一个参数继续传递参与运算，直到list中的所有元素被遍历
• fold与reduce很像，但是多了一个指定初始值参数
• foldLeft和foldRight有一种缩写方法对应分别是：/:和:\
• 方法签名
  • 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表示从右往左计算
• 案例

val a = List(1,2,3,4,5,6,7,8,9,10)
a.fold(10)(_ + _)//65