scala 学习笔记 --高阶函数

import scala.math._
val num=3.14
val fun = ceil _

scala中函数和数字一样,可以在变量中存放,如fun所示,ceil为math中的一个函数,ceil后的_意味着确实指的是这个函数,而不是碰巧忘了给它传递参数(不可省略).从技术上讲,_讲ceil方法转成了函数.在scala中,你无法直接操纵方法,而只能直接操纵函数.对于函数可以做两件事:1.调用;2.传递

val res = fun(num)//res: Double = 4.0
Array(3.14,1.42,2.0).map(fun)//Array(4.0,2.0,2.0)

带函数参数的函数

def valueAtOneQuarter(f:(Double)=>Double)=f(0.25)
valueAtOneQuarter(ceil _)//1.0   等同于ceil(0.25)

valueAtOneQuarter称为高阶函数,因为其是一个接受函数参数的函数.高阶函数还可以产出另一个函数

def mulBy(factor:Double):(Double)=>Double=(x:Double)=>factor*x//(x:Double)=>factor*x是一个函数,所以mulBy函数的返回值是一个函数,Double=>Double
  val quintuple=mulBy(5)
  val res1=quintuple(20)//res1:Double=100.0

参数类型推断

def valueAtOneQuarter(f:Double=>Double)=f(0.25)
  def f1=valueAtOneQuarter((x:Double)=>x*3)
  //由于scala有参数类型推断,所以以上方法可以写作以下形式
  def f2=valueAtOneQuarter((x)=>x*3)//valueAtOneQuarter知道传入类型为(Double)=>Double
  def f3=valueAtOneQuarter(x=>x*3)//对于只有一个参数的函数,可以省去()
  def f4=valueAtOneQuarter(_*3)//如果参数在=>只出现一次,可以用_替换掉它
  //以上这些方法尽在参数类型已知的情况下有效
  //val fun1=3 * _ //错误,无法推断出类型
  val fun2=3*(_:Double)
  val fun3:(Double)=>Double=3*_

闭包

val triple=mulBy(3)
val half=mulBy(0.5)
println(triple(14) +" "+ half(14))//42.0 7.0

如上所示,每个返回的函数 triple和half都有自己的factor设置,这样的函数被称作闭包,函数可以在变量不再处于作用域内时被调用.这些函数实际上是以类的对象方式实现的,该类有一个实力变量factor和一个包含函数体的apply方法

可以将函数传递给变量

scala> val fun=(x:Double)=>x*3  这与

scala> def fun=(x:Double)=>x*3  的结果一样

可以将一个函数传递给另一个函数

scala> val a =Array(1,2,3.0).map((x:Double)=>x*3)//此处为匿名函数

a: Array[Double] = Array(3.0, 6.0, 9.0)

也可以将函数包在花括号中，而不是圆括号中

scala> Array(2,4,6.0).map{(x:Double)=>x*3}
res2: Array[Double] = Array(6.0, 12.0, 18.0)

定义一个接受另一个函数作为参数的函数

SAM转换(单个抽象方法single abstract method)

柯里化--将原来接受两个参数的函数变成新的接受一个函数的过程.新的函数返回一个以原有第二个参数作为参数的函数

例:

def mul(x:Int,y:Int)=x*y
def mulOneAtATime(x:Int)=(y:Int)=>x*y//实际上是返回了一个函数
def mulOneAtATime2(x:Int)(y:Int)=x*y//scala支持的柯里化函数定义
val m1=mul(5,6)
val m2=mulOneAtATime(5)(6)
val m3=mulOneAtATime2(5)(6)

控制抽象--看上去像是编程语言关键字的函数.

scala中将一系列语句归组成不带参数也没有返回值的函数.例如:

def runInThread(block:()=>Unit): Unit ={//传入参数的类型为()=>Unit,即无输入参数,返回值类型为Unit
    new Thread{
      override def run(): Unit = {
        block()
      }
    }.start()
  }
  runInThread{() => println("Thread Start...");Thread.sleep(1000);println("Thread End!")}

  def runInThread2(block: =>Unit): Unit ={//可以省略(),保留=>.煮雨,block:后面必须接一个空格.
    new Thread{
      override def run(): Unit = {
        block
      }
    }.start()
  }
  runInThread2{println("Thread2 Start...");Thread.sleep(1000);println("Thread2 End!")}

运用scala的这个语法特点构建一个类似关键字的函数until,与while类似,但是执行条件相反

def until(conditidon: =>Boolean)(block: =>Unit){
    if (!conditidon) {
      block
      until(conditidon)(block)
    }
  }

<pre name="code" class="java">var x=10
until(x==0){
      x -= 1
      println(x)
    }

此处也用到了柯里化

return表达式

scala中不需要使用return语句来返回函数值.函数的返回值就是函数体的值

不过可以用return从一个匿名函数中返回值给包含这个匿名函数的带名函数.例如:

def indexOf(str:String,ch:Char): Int ={
    var i=0
    until(i==str.length){
      if(str.charAt(i)==ch)return i
      i+=1
    }
    return -1
  }

在这里,当 return i 表达式执行时,包含它的带名函数indexOf终止并返回给定的值.需要注意的是,如果在带名函数中使用return,则需要给出其返回类型.例如indexOf的返回类型被指明为Int.