Scala---函数式编程（匿名函数，高阶函数map,flatMap,foreach,filter,partition,fold,reduce,groupBy等）

一、作为值的函数

	//要求有返回值的函数
    val fun:(String,Int)=>(Int,String)={
      (x,y)=>(y,x)
    }
    //调用函数并赋值
    val result = fun("zhangsan",33)
    //打印输出
    println(result)

    //创建方法
    def hello(name:String)={
      println(name)
    }
    hello("hhhhh")
    //将方法转换成函数，由变量去接受,函数不能转成方法
    val res=hello _
    //赋值
    res("hhh")

二、匿名函数

没有名字的函数，就是匿名函数，将参数列表和函数体使用"=>"连接起来，其作用是对参数列表中的参数，基于函数体进行操作，并类型推断其返回值。

三、高阶函数

一个有参数的函数，其参数是一个函数，函数在其参数列表中嵌套函数，或者使用函数作为输出结果，把这种函数我们称之为高阶(high level)函数。

	//高阶函数,调用函数的函数为高阶函数
    val funn=(x:Int)=>{
      x+1
    }
    //创建方法
    def met(f:Int=>Int)={
      f(1)+22
    }

    //创建使用方法
    def useMethod(f:Int=>Int,y:Int)={
      f(y)
    }

    //调用函数
    println(funn(2))
    println(met(funn))
    println(useMethod(funn, 5))

四、常见的高阶函数

1、map，flatMap ，foreach

	//创建数组
    val arr = Array(1,2,3,4,5,6)

    //将数组当中的每一个元素扩大10倍
    println(arr.map((x:Int) => x * 10).toBuffer)
    //简化版
    println(arr.map(x => x * 10).toBuffer)
    println(arr.map(_ * 10).toBuffer)

    //flatMap = map+flatten 原集合中的一个元素（这个元素也必须是集合），会转化为多个元素
    val arr1=Array(("a",1),("b",2),("c",3))
    val re1=arr1.flatMap(x => x._2 + x._1)
    re1.foreach(println)
    //另一种方法的实现
    arr1.map(x=>x._1+x._2).foreach(println)
    arr1.map(x=>x._1+x._2).flatten.foreach(println)

    //flatMap案例
    val arr2 = Array("ai bi ci","a b","g")
    //arr2.flatMap(x=>x.split(" ")).foreach(println)
    arr2.flatMap(_.split(" ")).foreach(println)

    //foreach
    val arr3 = Array(1,2,3,4,5)
    //遍历输出
    arr3.foreach(println)

2、filter:过滤

//filter:过滤
    val arr4 = Array(6, 3, 9, 7, -2)
    //过滤出来偶数
    val array = arr4.filter(x=>x%2==0)
    println(array.toBuffer)

    //filter过滤案例
    val arr5= Array("xiaohong","xiaolan","xiaomin","axiang")
    //过滤以a开头的名字
    arr5.filter(x=>x.startsWith("a")).foreach(println)
    //过滤以g结尾的元素
    arr5.filter(x=>x.endsWith("g")).foreach(println)
    //过滤出来包含h的元素
    arr5.filter(x=>x.contains("h")).foreach(println)
    //将数组中的偶数扩大10倍
    arr.filter(x=>x%2==0).map(_*10).foreach(println)

    //DropWhile:从左侧开始删除元素，直到遇到第一个不符合条件的元素，停止返回删除后新的数组
    //arr.dropWhile(_<4).foreach(println)
    println(arr.dropWhile(_ < 4).toBuffer)

3、partition:分区

只能一分为二,满足条件的放到Tuple2中的第一个元素的位置上，不满足条件的放到Tuple2的第二个元素的位置上

    //将数组中的元素分为奇偶数
    val par = arr.partition(x=>x%2==0)
    println(par._1.toBuffer) //ArrayBuffer(2, 4, 6)
    println(par._2.toBuffer) //ArrayBuffer(1, 3, 5)

4、fold和reduce

1、fold(zeroValue)((A1, A2) => A3)就是一个聚合函数，开始A1为zeroValue，A2为集合中第一个元素，聚合的结果就是A3，那么在下一次的聚合过程中，A3就成了A1。之后每一次拿着上一次聚合的结果A1和集合中的下一个元素A2进行聚合。
2、foldRight(zeroValue)((A1, A2) => A3)就是一个聚合函数，开始A2为zeroValue，A1为集合（从右往左取）中第一个元素，聚合的结果就是A3，那么在下一次的聚合过程中，A3就成了A2。之后每一次拿着上一次聚合的结果A2和集合（从右往左取）中的下一个元素A1进行聚合。
3、reduce((A1, A2) => A3)就是一个聚合函数，开始A1,A2为集合中前两个元素，聚合的结果就是A3，那么在下一次的聚合过程中，A3就成了A1。之后每一次拿着上一次聚合的结果A1和集合中的下一个元素A2进行聚合。
4、reduceRight((A1, A2) => A3)就是一个聚合函数，开始A1,A2为集合（从右往左取）中前两个元素，A2为第一个元素，聚合的结果就是A3，那么在下一次的聚合过程中，A3就成了A2。之后每一次拿着上一次聚合的结果A2和集合（从右往左取）中的下一个元素A1进行聚合。

	//fold:简化折叠
    val fol=arr.fold(1)((sum:Int,num:Int)=>{
      println(s"$sum----$num")
      sum+num
    })
    println(fol)
    /*1----1
    2----2
    4----3
    7----4
    11----5
    16----6
    fol: Int = 22*/
    //简化版
    val fol1=arr.fold(1)((sum,num)=>sum+num)
    val fol2=arr.fold(1)(_+_)
    println(fol2)
    //相减
    val fol3=arr.fold(1)(_-_)
    val fol4=arr.fold(1)((sum:Int,num:Int)=>{
      println(s"$sum----$num")
      sum-num
    })
    /*1----1
    0----2
    -2----3
    -5----4
    -9----5
    -14----6
    fol4: Int = -20*/

    //1-1=0  0-2=-2  -2-3=-5 -5-4=-9  -9-5=-14  -14-6=-20

    //foldRight
    val fol5=arr.foldRight(0)((sum:Int,num:Int)=>{
      println(s"$sum----$num")
      sum-num
    })
    /*
    6----0
    5----6
    4-----1
    3----5
    2-----2
    1----4
    fol4: Int = -3*/

    //foldLeft与fold相同
    val fol6= arr.foldLeft(1)(_-_)
    val fol7= arr.foldLeft(1)((sum:Int,num:Int)=>{
      println(s"$sum----$num")
      sum-num
    })

    //reduce与fold相同只不过没有一个初始值
    val red=arr.reduce(_+_)

    //reduceLeft
    val result = arr.reduceLeft(_-_)
    val result1 = arr.reduceLeft((sum:Int,num:Int)=>{
      println(s"$sum----$num")
      sum-num
    })
    //打印输出
    println(result)
    //reduceRight
    val result3 = arr.reduceRight(_-_)
    val result4 = arr.reduceRight((sum:Int,num:Int)=>{
      println(s"$sum----$num")
      sum-num
    })
    /*5----6
    4-----1
    3----5
    2-----2
    1----4
    result4: Int = -3*/
    //打印输出
    println(result3)

5、groupBy

	//groupBy
    val stus = Array(
      "1,田志,male",
      "2,李威,male",
      "4,范帅,female",
      "5,郭颖丽,female"
    )

    //按照性别分组,lastIndexOf方法用于获取指定元素在集合中的最后一次出现的索引
    val gro=stus.groupBy(line => line.substring(line.lastIndexOf(",") + 1))
    //遍历输出
    gro.foreach(x=>{println(x._1)
      println(x._2.toBuffer)}
    )
    /*male
	ArrayBuffer(1,田志,male, 2,李威,male)
	female
	ArrayBuffer(4,范帅,female, 5,郭颖丽,female)*/

五、闭包

方法体当中的匿名函数运算调用了方法的参数列表就叫闭包