学习Spark--(6)--高阶函数

Scala高级特性

1. 高阶函数

--1--概念

Scala混合了面向对象和函数式的特性，我们通常将可以作为参数传递到方法中的表达式叫做函数。在函数式编程语言中，函数是“头等公民”，把函数作为参数或者是返回值是函数叫高阶函数。

高阶函数包含：作为值的函数、匿名函数、闭包、柯里化等等。

--2-- 作为值的函数

可以像任何其他数据类型一样被传递和操作的函数，每当你想要给算法传入具体动作时这个特性就会变得非常有用。

/**
  * 作为值的函数
  */
object MyFunction {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    val arr: Array[Int] = Array(1, 2, 3, 4)
    //定义一个函数并将函数复制给fun1
    val fun1 = (x: Int) => {
      x * 2
    }
    //同过map方法把调用fun1函数
    val map: Array[Int] = arr.map(fun1)

    map.foreach(line => {
      println(line)
    })
  }
}

定义函数时格式：val 变量名 = (输入参数类型和个数) => 函数实现和返回值类型

“=”表示将函数赋给一个变量

“=>”左面表示输入参数名称、类型和个数，右边表示函数的实现和返回值类型

--3--匿名函数

在scala中，不需要给每一个函数命名，没有将函数赋值给变量的函数叫做匿名函数

object anonFunction {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    val arr: Array[Int] = Array(1, 2, 3, 4)
    //map里面的就是匿名函数
    val map: Array[Int] = arr.map((x: Int) => {
      x * 2
    })
    map.foreach(line => {
      println(line)
    })
  }
}

由于Scala可以自动推断出参数的类型，所以还可以精简为

//map里面的就是匿名函数
val map: Array[Int] = arr.map(x => {
  x * 2
})

更简单的

val map: Array[Int] = arr.map(_ * 2)

--4--递归函数

 /**
     * 递归函数 
     * 5的阶乘
     */
    def fun2(num :Int) :Int= {
      if(num ==1)
        num
      else 
        num * fun2(num-1)
    }
    print(fun2(5))

--5--嵌套函数

    /**
     * 嵌套函数
     * 例如：嵌套函数求5的阶乘
     */
    def fun5(num:Int)={
      def fun6(a:Int,b:Int):Int={
        if(a == 1){
          b
        }else{
          fun6(a-1,a*b)
        }
      }
      fun6(num,1)
    }
    println(fun5(5))

--6--柯里化

1) 什么是柯里化

柯里化指的是把原来接受多个参数的函数变换成接受一个参数的函数过程，并且返回接受余下的参数且返回结果为一个新函数的技术

2) 例子

(1) 一个普通的非柯里化的函数定义，实现一个加法函数

scala> def plainOldSum(x:Int,y:Int)=x+y
plainOldSum: (x: Int, y: Int)Int

scala> plainOldSum(1,2)
res0: Int = 3

(2) 使用“柯里化”技术来定义这个加法函数，原来函数使用一个参数列表，“柯里化”，把函数定义为多个参数列表：

scala> def curriedSum(x:Int)(y:Int)=x+y
curriedSum: (x: Int)(y: Int)Int

scala> curriedSum(1)(2)
res1: Int = 3

//当你调用curriedSum (1)(2)时，实际上是依次调用两个普通函数（非柯里化函数），
//第一次调用使用一个参数x，返回一个函数类型的值，
//第二次使用参数y调用这个函数类型的值。

(3) 使用下面两个分开的定义在模拟curriedSum柯里化函数：

//首先定义第一个函数：
scala> def first(x:Int)=(y:Int)=>x+y
first: (x: Int)Int => Int

//然后我们使用参数1调用这个函数来生成第二个函数：
scala> val second =first(1)
second: Int => Int = <function1>
scala> second(2)
res2: Int = 3

(4) 使用curriedSum 来定义second

scala> val onePlus=curriedSum(1)_
onePlus: Int => Int = <function1>

//下划线“_” 作为第二参数列表的占位符， 这个定义的返回值为一个函数，当调用时会给调用的参数加一。

scala> onePlus(2)
res3: Int = 3
//调用生成的函数，给函数传入参数，即可得到我们想要的结果

3) 总结

scala柯里化风格的使用可以简化主函数的复杂度，提高主函数的自闭性，提高功能上的可扩张性、灵活性。可以编写出更加抽象,功能化和高效的函数式代码。

2. 隐式转换和隐式参数

--1--隐式转换

Scala提供的隐式转换和隐式参数的功能，是非常有特色的功能。是Java等编程语言所没有的功能。它可以允许你手动指定，将某种类型的对象转换成其他类型的对象，或者是给一个类的增加方法。通过这些功能，可以实现非常强大、特殊的功能。其中所有的隐式值和隐式方法必须放到object中。

然而使用Scala的隐式转换是有一定限制的：

implicit关键字只能用来修饰方法、变量、(参数)

隐式转换的方法在当前范围内才有效。如果隐式转换不再当前范围内定义(比如定义在另一个类中或者包含在某个对象中)，那么必须通过import语句将其导入。

import Scala01.f1

隐式转换函数名可以是任意的，隐式转换与函数名有关，只与函数参数类型和返回值类型有关

隐式函数可以有多个，就是隐式函数列表，但是必须保证在当前环境下，只有一个隐式函数能被识别

object Scala03 {
  def main(args: Array[String]): Unit = {
      implicit def f1(double: Double): Int ={
        double.toInt
      }

    implicit def f2(double: Double): Int = {
      double.toInt
    }
    implicit def f3(float: Float): Int ={
      float.toInt
    }
    val a:Int=2.34
  }

}

隐式装换需要隐式装换的方法，例如：

implicit def f1(d: Double): Int = {
   d.toInt
 }

--2--对象转换案例

1). Int隐式转换为Double

object Scala01 {

//定义一个隐式转换的方法 实现double-->int
  implicit def f1(d: Double): Int = {
    d.toInt
  }
  def main(args: Array[String]): Unit = {
    //转换成功
    val a: Int = 4.5
    val b: Int = 5.6
  }
  def function01(): Unit ={
    val c:Int=1.123123
  }

2).给Mysql类增加一个delete的方法

/**
  * 动态的给Mysql增加delete 方法
  */
object Scala04 {
  def main(args: Array[String]): Unit = {
    //隐式方法
    implicit def addDelete(mysql: Mysql): DB = {
      new DB
    }

    //创建msyql
    val mysql: Mysql = new Mysql()
    mysql.insert()
    //增加一个删除的方法
    mysql.delete()
  }
}

class Mysql {
  def insert(): Unit = {
    println("insert into  data  database")
  }

}

class DB {

  def delete(): Unit = {
    println("delete   data  from database")
  }
}

--3--扩展知识

1)让File类具备RichFile类中的read方法

import java.io.File
import scala.io.Source

object MyPredef{
  //定义隐式转换方法
  implicit def file2RichFile(file: File)=new RichFile(file)
}
class RichFile(val f:File) {
  def read()=Source.fromFile(f).mkString
}
object RichFile{
  def main(args: Array[String]) {
    val f=new File("E://words.txt")
    //使用import导入隐式转换方法
    import MyPredef._
    //通过隐式转换，让File类具备了RichFile类中的方法
    val content=f.read()
    println(content)
  }
}

2) 超人变身

class Man(val name:String)
class SuperMan(val name: String) {
  def heat=print("超人打怪兽")
}
object SuperMan{
  //隐式转换方法
  implicit def man2SuperMan(man:Man)=new SuperMan(man.name)
  def main(args: Array[String]) {
      val hero=new Man("hero")
      //Man具备了SuperMan的方法
      hero.heat
  }
}

3) 一个类隐式转换成具有相同方法的多个类

class A(c:C) {
    def readBook(): Unit ={
      println("A说：好书好书...")
    }
}
class B(c:C){
  def readBook(): Unit ={
    println("B说：看不懂...")
  }
  def writeBook(): Unit ={
    println("B说：不会写...")
  }
}
class C
object AB{
  //创建一个类的2个类的隐式转换
  implicit def C2A(c:C)=new A(c)
  implicit def C2B(c:C)=new B(c)
}
object B{
  def main(args: Array[String]) {
    //导包
    //1. import AB._ 会将AB类下的所有隐式转换导进来
    //2. import AB._C2A 只导入C类到A类的的隐式转换方法
    //3. import AB._C2B 只导入C类到B类的的隐式转换方法
    import AB._
    val c=new C
    //由于A类与B类中都有readBook()，只能导入其中一个，否则调用共同方法时代码报错
    //c.readBook()
    //C类可以执行B类中的writeBook()
    c.writeBook()
  }
}

4) 员工领取薪水

object Company{
  //在object中定义隐式值    注意：同一类型的隐式值只允许出现一次，否则会报错
  implicit  val aaa="zhangsan"
  implicit  val bbb=10000.00
}
class Boss {
  //注意参数匹配的类型   它需要的是String类型的隐式值
  def callName()(implicit name:String):String={
    name+" is coming !"
  }
  //定义一个用implicit修饰的参数
  //注意参数匹配的类型    它需要的是Double类型的隐式值
  def getMoney()(implicit money:Double):String={
    " 当月薪水："+money
  }
}
object Boss extends App{
  //使用import导入定义好的隐式值，注意：必须先加载否则会报错
  import Company._
  val boss =new Boss
  println(boss.callName()+boss.getMoney())

}