Scala之 闭包和柯里化

package com.uplooking.bigdata.p3
 
/**
  * Scala中关于函数的各种操作
  */
object FunctionOps {
 
 
  def main(args: Array[String]): Unit = {
//    functionOps1
//    functionOps2
//    functionOps3
//    functionOps4
    functionOps5
 
  }
 
  /**
    * 闭包和柯里化
    *
    * 1、柯里化(currying)指的是将原来接受2个参数的函数变成新的接受一个参数的函数的过程。
    * 新的函数返回一个以原有第二个参数作为参数的函数。
      2、在函数调用的过程中，就变为了两个函数连续调用的形式。在Spark源码中，也有体现，
    所以对()()这种形式的Curring函数，一定要掌握。
      以下函数接受一个参数，生成另一个接受单个参数的函数。
 
    */
  def functionOps5: Unit = {
 
    def mulBy(factor:Double) = (x:Double) => factor * x
    //把函数赋值给一个变量
    val a = mulBy(3)
    val b = mulBy(2)
 
    println(a(5) + "..." + b(5))
 
    println("---------柯里化---------------")
 
    println(mulBy(3)(4))
    def sum(x:Int, y:Int) = println(x + y)
    sum(3, 5)
    println("----柯里化上述的sum函数---")
 
    def curringSum(m:Int) = (n:Int) => println(m + n)
    curringSum(3)(5)
    println("---------return--------------------")
    //?scala中return的作用
    def returnFunction(name:String):String ={
      def sayGoodBayToGarry(name: String):String = {
        "Good morning ==> , " + name
      }
      sayGoodBayToGarry(name)
    }
 
    println(returnFunction("李四"))
  }
 
  def functionOps4: Unit = {
    /*
    * 下面的案例中，我们可以使用“_”去代表遍历集合中当前的元素
    * */
//    (1 to 5).map(0.1 * _).foreach(println(_))
    val range = 1 to 5
 
    val range1 = range.map(x => x * 0.1)
    range1.foreach(d => println("D: " + d))
    println("---------------------------")
    (1 to 5).map("*" * _).foreach(println)
    println("-----------Filter----------------")
    //过滤集合中的偶数，奇数
    (1 to 10).filter(_ % 2 == 0).foreach(x => print(x + " "))
    println
    (1 to 10).filter(x => x % 2 != 0).foreach(x => print(x + " "))
    println("\n---------------Reduce操作-----------------")
 
    /*
    * mr中计算wordcount
    *   reduce阶段
    *     r_input k2, v2s
    *     v2s--->出现的k2所对应的一个个的值，是一个列表
    *   最终要统计出k2对应的总次数
    *   long sum = 0;
    *   for(v2 : v2s) {
    *       sum += v2;
    *   }
    *   sum = sum + v2s-1
    *   sum = sum + v2s-2
    *   ....
    *   sum
    *
    * reduce操作，是一个二元操作，这个reduce、map、filter
    * */
//    val ret = (1 to 10).reduceRight((x1, x2) => x1 + x2)
    val ret = (1 to 10).reduce(_ + _)
    println("1 + ... + 10 = " + ret)
    //1 + ... + 10
//    println(sum)
 
    println("-----------------sortWith----------------------")
    (1 to 10).sortWith(_ > _).foreach(x => print(x + " "))
    //数组中的元素按照字符串长度降序排序
    println
//    "Marry has a little lamb".split(" ").sortWith((str1, str2) => str1.length > str2.length).foreach(x => print(x + " "))
//    "Marry has a little lamb".split(" ").sortWith(_.length > _.length).foreach(x => print(x + " "))
    "Marry has a little lamb".split(" ").sortWith(_ > _).foreach(x => print(x + " "))
  }
 
  def sum = {
//    var sum = 0
//    for(x <- 1 to 10) {
//      sum += x
//    }
//    sum
    (1 to 10).sum
  }
  /**
    * 高阶
    *   函数在参数列表里面还嵌套有匿名函数，把这种函数称之为高阶函数
    *
    *   简单一点的理解，就是说在函数定义的时候，参数函数是抽象的，那么在具体的函数调用的过程中对
    *  该抽象函数进行具体实现
    *    那么这个参数函数，其实说白了就是我们在functionOps2的匿名函数
    */
  def functionOps3: Unit = {
      //高阶函数的定义
      def sayHello(func: (String) => Unit, name: String) = func(name)
      sayHello((name:String) => println("Hello " + name + ",您吃了吗？"), "陈佳斌")
  }
  /**
    * 匿名函数
    * 将匿名函数赋值给一个变量，那么这个变量就相当于给这个匿名函数临时起了一个函数名，
    * 调用的时候，直接使用变量名，加上参数即可
    */
  def functionOps2 {
    val sayHi = (name:String) => println("Hello " + name)
 
    sayHi("小丁丁")
  }
  /**
    * 将函数作为值，传递给另外的函数
    * 在传递的时候，只需要传递函数名即可，但是在将函数名作为值传递的时候，需要在函数名后面必须跟上空格加_
    *
    */
  def functionOps1: Unit = {
    def sayGoodBye(name: String) = println("goodbye " + name + ", see you tomorrow")
    def sayBye = sayGoodBye _
 
    sayBye("赵远")
  }
 
}