Scala的高阶函数的使用

map函数

语法：list.map(A=>B):List[B]
	final def map[B](f: (A) ⇒ B): List[B]
	//map函数只有1个参数，这个参数是一个函数类型
	f: (A) ⇒ B：f就是参数函数
	//f有1个参数：A：代表集合中的每个元素
	//f的返回值：B：B是A处理以后的返回值
	List[A].map = List[B]
	A1   ->  B1
		A2   ->  B2
	……
	栗子
	val list1 = List(1,2,3,4,5,6,7,8,9,10)
	scala> list1.map((numb) => {
	     |    println(numb)
	     |    numb*numb
	     | })
	1
	2
	3
	4
	5
	6
	7
	8
	9
	10
	res0: List[Int] = List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)


scala> list1.map(numb => numb*numb)
res1: List[Int] = List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

foreach

语法:list.foreach(f:A => Unit):Unit
final def foreach(f: (A) ⇒ Unit): Unit
//foreach有1个参数，是一个函数f
//f这个函数有1个参数：A：代表集合中的每个元素
//f这个函数没有返回值
 scala> list1.foreach(i => println(i))
  1
2
3
4
  5
  6
  7
8
  9
  10
  
scala> list1.foreach(println(_))
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  
  scala> list1.foreach(println)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

flatMap

final def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): List[B]
//flatMap有1个参数f,是一个函数
//f这个函数有1个参数：A：集合中的每个元素
//f这个函数有返回值： GenTraversableOnce[B]，对每个A处理以后返回的结果，是一个集合，集合中有
多个元素B
//flatMap返回值是：List[B]：将每个A返回的集合进行合并

基本原理：f：调用每个元素进行map处理，map返回值是List，每个元素放回一个集合，最终每个元素处
理的结果：List[List[B]]
flatMap会将这个List[List[B]] 变成List[B]
栗子
val m1 = Map("key1"->"1,2,3","key2"->"4,5,6","key3"->"7,8,9")
scala> m1.values
res11: Iterable[String] = MapLike(1,2,3, 4,5,6, 7,8,9)
栗子
val list5 = List("hadoop spark"," spark","hive hbase ","hue hue spark"," hue ")
scala> list5.flatMap(line => line.split(" "))
res14: List[String] = List(hadoop, spark, "", spark, hive, hbase, hue, hue, spark, "", hue)

scala> list5.flatMap(line => line.trim.split(" "))
res15: List[String] = List(hadoop, spark, spark, hive, hbase, hue, hue, spark, hue)

groupBy

def groupBy[K](f: (A) ⇒ K): Map[K, List[A]]
//groupBy传递一个参数f：函数参数
//f有一个参数：A：每个元素
	5
	(key,value)
	(tup1,tup2,tupe3)
//f有一个返回值：K：按照谁分组
//groupBy返回值：Map[K, List[A]]，每个KV代表一组
	K：分组的那个组
	V：List[A]，符合K的所有A的集合
栗子
**val list3 = List(2,4,6,8,9,7,5,3,1)**
scala> list3.groupBy( x => x%2==0).foreach(println)
(false,List(9, 7, 5, 3, 1))
(true,List(2, 4, 6, 8))
栗子
val m2 = Map(1->"shanghai",2->"beijing",3->"jiangsu",4->"anhui",5->"beijing",6->"anhui",7->"anhui",8-
>"shanghai",9->"beijing",10->"beijing")
scala> m2.groupBy(tuple => tuple._2).foreach(println)
(jiangsu,Map(3 -> jiangsu))
(shanghai,Map(1 -> shanghai, 8 -> shanghai))
(anhui,Map(6 -> anhui, 7 -> anhui, 4 -> anhui))
(beijing,Map(5 -> beijing, 10 -> beijing, 9 -> beijing, 2 -> beijing))

filter

用于实现对集合中的数据进行过滤，将符合条件表达式的数据放入一个新的集合返回

val list2 = List("hadoop","","hive","hue"," ")
scala> list2.filter(word => word.trim.length > 0)
  res22: List[String] = List(hadoop, hive, hue)
  
  scala> list2.filter(_.trim.length > 0)
  res23: List[String] = List(hadoop, hive, hue)
语法:def filter(A => 条件表达式)：List[A]

sortBy

def sortBy[B](f: (A) ⇒ B)(implicit ord: math.Ordering[B]): List[A]
//sortBy传递一个参数f：函数
//f的参数：A：集合中的每个元素
//f的返回值：B：按照A中的什么进行排序
//sortBy返回的是排序好的结果


val list3 = List(2,4,6,8,9,7,5,3,1)
val list4 = List(("zhangsan",20,"male"),("lisi",30,"female"),("wangwu",19,"male"))

fold

def fold(z: A1)(op: (A1, A1) ⇒ A1): A1
//fold：两个参数
//z：临时变量的初始值
//op：函数:聚合逻辑
(T,A) => B
	T：临时变量
A：集合中的每个元素
	B：聚合的结果

val list3 = List(2,4,6,8,9,7,5,3,1)
list3.fold(1)((tmp,item) => tmp*item)

list3.fold(1)((tmp,item) => {
	println(s"tmp = ${tmp}  item = ${item}")
	tmp*item
})

语法:
 fold(Zero)((T,A) => T):TZero：
 T的初始值T：临时变量，存储计算的结果
 A：每个元素