scala函数式编程--第三种用法

?

package chapter05

object scala06_FunctionHigh2 {
  def main(args: Array[String]): Unit = {
    /*
    高阶函数第二种用法  函数可以作为一个参数进行传递
     */


    //    需求：定义一个求和功能
    def sumAB(a: Int, b: Int): Int = {
      a + b

    }

    println(sumAB(10, 20))

    //    计算 乘法 除法 求余
    //    传统思路
    //    最佳实践：（将具体的计算罗杰封装一个函数体现
    def ooperaAB(a: Int, b: Int, fun: (Int, Int) => Int): Int = {
      fun(a, b)
    }
//调用封装好的operAb
val i :Int= ooperaAB(10, 10, (a: Int, b: Int) => a + b)
    var i1: Int = ooperaAB(10, 10, (a: Int, b: Int) => a + b)
    println(i)
//    化简
val i2 :Int= ooperaAB(10, 10, (a: Int, b: Int) => a + b)

    val i3 :Int= ooperaAB(10, 10, (a,b) => a + b)
    val i4 :Int= ooperaAB(10, 10,  _ + _)

//    TODO 结合实践使用的框架技术来说明第二种用法的意义
//回顾 hadoop  MR计算流程（面向对象）
//    1自定义Mapper 需要继承 Hadoop提供的Mapper组件，并且重写
//      ....
//  .......
//    使用面向函数式编程实现MR流程。。。。。
//    计算字符串的长度

//    步骤一：封装整体流程
    def mapReduce(data:String,map:(String)=>Int,reduce:(Int)=>String): String ={
//      执行流程
      println("map 流程 start....")

      val mapRes: Int = map(data)
      println("Shuffle 流程 start....")
      println("reduce 流程 start....")
      val reduceRes: String = reduce(mapRes)
      reduceRes

    }

    //    步骤二： 具体进行流程计算
    val data: String = "下周元旦"
    val res: String = mapReduce(data, (str: String) => str.length,
      (strLen: Int) => "当前字符串长度为：" + strLen)
    println(res)


  }


}

package scala01

object scala01_fun_02 {
  //  函数可以作为返回值
  def main(args: Array[String]): Unit = {
    //    函数第三种用法

    //    需求 定义两数之和，但是求和过程中不会直接将两个数传递函数，一个一个传
    def sumXY(x: Int) = {
      //      TODO 可能会对x做一些处理
      //  可能存在一些具体逻辑 ..
      def sumY(y: Int): Int = {
        x + y
      }
      //      将内部的sumY函数作为返回值进行返回
      sumY _
      //      下滑线**
    }

    //传统调用方式
    val function: Int => Int = sumXY(10)
    println(function(5))
    println(sumXY(10))
    //TODO 推荐使用简易化的调用
    val res: Int = sumXY(20)(20) //柯里化调用.... Currying
    //
    println(res)

    //    化简
    //    sumY函数代码只有一行可以省略 大括号可省略 返回值类型可以推断
    def sumXY2(x: Int): Int => Int = {
      def sumY(y: Int) = x + y

      sumY _
    }

    //sumY 换成匿名函数
    def sumXY3(x: Int): Int => Int = {
      //      def sumY(y: Int) = x + y
      (y: Int) => x + y
      //      sumY _
    }

//    当前代码块 中只有一行

    def sumXY4(x: Int): Int => Int = (y: Int) => x + y

//    化简sumXY 成匿名函数

    val intToIntToInt: Int => Int => Int = (x: Int) => (y: Int) => x + y


//    匿名函数化简。参数类型省略(推荐就此）
val func1: Int => Int => Int = x => y => x + y
//    使用下划线(嵌套函数使用的时候，只能考虑最里面的函数使用下划线
val func2: Int => Int => Int = x=> x + _


  }

}

package scala01

object scala07_Currying {

  def main(args: Array[String]): Unit = {
    //    TODO 定义一个函数 func1(int char string) 判断传入的参数 如果（0,'0',"") 返回false ：true
    //    TODO func2(int)(char)(String),判断传入的参数 如果（0）,（'0'）,（""）) 返回false ：true


    def func1(x: Int, y: Char, z: String): Boolean = {
      if (x == 0 && y == '0' && z == "") {
        false
      }
      else {
        true
      }
    }

    println(func1(0, '0', ""))

    //  化简
    val function: (Int, Char, String) => Boolean = (i: Int, c: Char, s: String) => i != 0 || c != '0' || s != ""

    def func3(i: Int) = {
      def func4(c: Char) = {
        def func5(s: String): Boolean = {
          i != 0 || c != '0' || s != ""

        }

        func5 _
      }

      func4 _
    }
    //    Currying

    func3(0)('0')("0")
    //    化简 从里到外
//        1匿名
val function1: Int => Char => String => Boolean = (i: Int) => (c: Char) => (s: String) => i != 0 || c != '0' || s != ""
//      2 根据类型推断
val function2: Int => Char => String => Boolean =
  i => c => s => i != 0 || c != '0' || s != ""

//3 下划线
val function3: Int => Char => String => Boolean =
  i => c => i != 0 || c != '0' || _ != ""

//    TODO 针对嵌套式函数进行Currying声明
    def function(i:Int)(c:Char)(s:String)=i => c => i != 0 || c != '0' || _ != ""



  }
}