0014. 最常用的10个函数组合子

组合就是以下函数的各种链式组合，以下每个函数都称为组合子。

map

val lst = List(1,2,3,4,5)
def mul(n:Int):Int = {
   n*2
}
lst.map(mul)
lst.map((n:Int) => n*2)

返回List(2,4,6,8,10)。

foreach
很像map，但是没有返回值，如果一定要赋值给某个变量，返回值是Unit = ()。

val lst = List(1,2,3,4,5)
val s = lst.foreach(mul)   // s: Unit = ()

还可以用foreach来遍历Map映射：

val m = Map("name"->"monkey", "age"->12)
m.foreach{
   case (k,v) => println(k, v)
}

filter
移除任何对传入的谓词函数计算结果为false的元素。啥是谓词函数，就是返回一个布尔值的函数，也叫判定函数。

val lst = List(1,2,3,4,5)
val s = lst.filter((n:Int) => n>2)

返回List(3,4,5)，显然，谓词函数并不能改变元素的结构，只能选择留或不留。

zip
将两个列表的内容聚合到一个tuple2列表中：

val lst1 = List("monkey", "mouse", "elephant")
val lst2 = List(12, 13, 14)
val temp = lst1.zip(lst2)

返回List[(String, Int)] = List((monkey,12), (mouse,13), (elephant,14))。

unzip
和上面的操作相反：

val (a, b) = temp.unzip

a的值为List(monkey, mouse, elephant)，b的值为List(12, 13, 14)。

partition
使用给定的谓词函数分割列表。

val lst = List(1,2,3,4,5)
val a = lst.partition( _ > 4)
val b = lst.partition( _ < 4)

先找到符合谓词函数条件的值，归为一组，然后将剩下的归为一组。看a和b的值：

a: (List[Int], List[Int]) = (List(5), List(1, 2, 3, 4))
b: (List[Int], List[Int]) = (List(1, 2, 3), List(4, 5))

find
返回找到的第一个符合谓词函数的元素。

val lst = List(1,2,3,4,5)
lst.find(_ > 2)
// res0: Option[Int] = Some(3)

如果不存在的话，返回None。

drop
删除前n个元素。

val lst = List(1,2,3,4,5)
lst.drop(2)
// res0: List[Int] = List(3,4,5)

dropWhile
删除元素直到找到第一个符合谓词函数的元素。

val lst = List(1,2,3,4,5)
lst.dropWhile(_<3)
// res0: List[Int] = List(3,4,5)

foldLeft
给定初始值，然后做遍历操作，每次操作的返回将会被记录，做为遍历下个元素的初始值。

val lst = List(1,2,3,4,5)
lst.foldLeft(0)((a,b)=>a+b)

对foldLeft来说a是累加器，首次遍历，a的值是初始值0，每次遍历中将a+b的结果都将保存起来，作为下次遍历时参数a的值，最后求出累加值。

foldRight
变成从右边开始遍历，并且累加器变为参数b。

flatten
将嵌套结构扁平化为一个层次的集合。

val lst = List(List(1,2,3), List(4,5))
lst.flatten
// res0: List[Int] = List(1, 2, 3, 4, 5)

flatMap
组合了map和flatten的特征：

val lst = List(List(1,2,3), List(4,5))
lst.flatMap(n=>n.map(_*2))
// res0: List[Int] = List(2, 4, 6, 8, 10)

实际上就是下面的组合：

lst.map((x:List[Int])=>x.map(_*2)).flatten
// res1: List[Int] = List(2, 4, 6, 8, 10)