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("赵远")

  }

 

}