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 的结果一样
可以将一个函数传递给另一个函数
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.