一、偏函数(partial function)
1、基本介绍
-
在对符合某个条件,而不是所有情况进行逻辑操作时,使用偏函数是一个不错的选择
-
将包在大括号内的一组case语句封装为函数,我们称之为偏函数,它只对会作用于指定类型的参数或指定范围值的参数实施计算,超出范围的值会忽略(未必会忽略,这取决于你打算怎样处理)
-
偏函数在Scala中是一个特质PartialFunction
2、实例
一个集合val list = List(1, 2, 3, 4, "abc") ,请完成如下要求:
将集合list中的所有数字+1,并返回一个新的集合
要求忽略掉 非数字 的元素,即返回的 新的集合 形式为 (2, 3, 4, 5)
object FunctionTest {
def main(args: Array[String]): Unit = {
val list = List(1, 2, 3, 4, "abc")
//说明
val addOne3= new PartialFunction[Any, Int] {
def isDefinedAt(any: Any) = if (any.isInstanceOf[Int]) true else false
def apply(any: Any) = any.asInstanceOf[Int] + 1
}
val list3 = list.collect(addOne3)
println("list3=" + list3) //?
}
}
-
使用构建特质的实现类(使用的方式是PartialFunction的匿名子类)
-
PartialFunction 是个特质(看源码)
-
构建偏函数时,参数形式 [Any, Int]是泛型,第一个表示参数类型,第二个表示返回参数
-
当使用偏函数时,会遍历集合的所有元素,编译器执行流程时先执行isDefinedAt()如果为true ,就会执行 apply, 构建一个新的Int 对象返回
-
执行isDefinedAt() 为false 就过滤掉这个元素,即不构建新的Int对象.
-
map函数不支持偏函数,因为map底层的机制就是所有循环遍历,无法过滤处理原来集合的元素
-
collect函数支持偏函数
3、偏函数简化形式
声明偏函数,需要重写特质中的方法,有的时候会略显麻烦,而Scala其实提供了简单的方法
object FunctionTest {
def main(args: Array[String]): Unit = {
def f2: PartialFunction[Any, Int] = {
case i: Int => i + 1 // case语句可以自动转换为偏函数
}
// 简化形式一
val list2 = List(1, 2, 3, 4,"ABC").collect(f2)
println(list2)
// 简化形式二
val list3 = List(1, 2, 3, 4,"ABC").collect{ case i: Int => i + 1 }
println(list3)
}
}
二、作为参数的函数
函数作为一个变量传入到了另一个函数中,那么该作为参数的函数的类型是:function1,即:(参数类型) => 返回类型
object FunctionTest {
def main(args: Array[String]): Unit = {
//说明:
def plus_1(x: Int) = 3 + x
def plus_2(x:Int):Int ={3 + x}
//说明
val result1 = Array(1, 2, 3, 4).map(plus_1)
val result2 = Array(1, 2, 3, 4).map(plus_1(_))
println(result1.mkString(","))
}
}
-
map(plus(_)) 中的plus(_) 就是将plus这个函数当做一个参数传给了map,_这里代表从集合中遍历出来的一个元素。
-
plus(_) 这里也可以写成 plus 表示对 Array(1,2,3,4) 遍历,将每次遍历的元素传给plus的 x
-
进行 3 + x 运算后,返回新的Int ,并加入到新的集合 result1中
-
def map[B, That](f: A => B) 的声明中的 f: A => B 一个函数
三、匿名函数
没有名字的函数就是匿名函数,可以通过函数表达式 来设置匿名函数
val triple = (x: Double) => 3 * x
println(triple(3))
-
(x: Double) => 3 * x 就是匿名函数
-
(x: Double) 是形参列表, => 是规定语法表示后面是函数体, 3 * x 就是函数体,如果有多行,可以 {} 换行写.
-
triple 是指向匿名函数的变量。
四、高阶函数
能够接受函数作为参数的函数,叫做高阶函数 (higher-order function)。可使应用程序更加健壮。
1、基本使用
object FunctionTest {
def main(args: Array[String]): Unit = {
val res = test(sum, 6.0)
println("res = " + res)
}
//test 就是一个高阶函数,它可以接收f: Int=> Double
def test(f: Int => Double, n1: Double) = {
f(n1.toInt)
}
//sum 是接收一个 Int,返回一个Double
def sum(d: Int): Double = {
d + d
}
}
2、高阶函数可以返回函数类型
def main(args: Array[String]): Unit = {
val result = minusxy(3)(5)
println(s"result = $result")
// 分步执行
val f1 = minusxy(3)
val result2 = f1(5)
println(s"result2 = $result2")
}
def minusxy(x: Int) = {
(y: Int) => x - y
}
}
(1)说明: def minusxy(x: Int) = (y: Int) => x - y
函数名为 minusxy
该函数返回一个匿名函数:(y: Int) = > x -y
(2)说明 : val result3 = minusxy(3)(5)
minusxy(3)执行minusxy(x: Int)得到 (y: Int) => 3 - y 这个匿名函
minusxy(3)(5)执行 (y: Int) => x - y 这个匿名函数
也可以分步执行: val f1 = minusxy(3); val res = f1(90)
五、参数(类型)推断
参数推断省去类型信息(在某些情况下[需要有应用场景],参数类型是可以推断出来的,如 list=(1,2,3) list.map() map中函数参数类型是可以推断的),同时也可以进行相应的简写。
1、参数类型推断写法说明
-
参数类型是可以推断时,可以省略参数类型
-
当传入的函数,只有单个参数时,可以省去括号
-
如果变量只在 => 右边只出现一次,可以用 _来代替
val list = List(1, 2, 3, 4)
println(list.map((x:Int)=>x + 1)) //(2,3,4,5)
println(list.map((x)=>x + 1))
println(list.map(x=>x + 1))
println(list.map(_ + 1))
val res = list.reduce(_+_)
2、上述例子小结
-
map是一个高阶函数,因此也可以直接传入一个匿名函数,完成map
-
当遍历list时,参数类型是可以推断出来的,可以省略数据类型 Int println(list.map((x)=>x + 1))
-
当传入的函数,只有单个参数时,可以省去括号 println(list.map(x=>x + 1))
-
如果变量只在=>右边只出现一次,可以用_来代替 println(list.map(_ + 1))
六、闭包(closure)
1、基本介绍:闭包就是一个函数和与其相关的引用环境组合的一个整体(实体)。
//1.用等价理解方式改写 2.对象属性理解
def minusxy(x: Int) = (y: Int) => x - y
//f函数就是闭包.
val f = minusxy(20)
println("f(1)=" + f(1)) // 19
println("f(2)=" + f(2)) // 18
2、小结
-
(y: Int) => x – y返回的是一个匿名函数 ,因为该函数引用到到函数外的 x,那么 该函数和x整体形成一个闭包,如:这里 val f = minusxy(20) 的f函数就是闭包
-
你可以这样理解,返回函数是一个对象,而x就是该对象的一个字段,他们共同形成一个闭包
-
当多次调用f时(可以理解多次调用闭包),发现使用的是同一个x, 所以x不变。
-
在使用闭包时,主要搞清楚返回函数引用了函数外的哪些变量,因为他们会组合成一个整体(实体),形成一个闭包
3、体会闭包的好处
def makeSuffix(suffix:String)=(filename:String)=>{
if(filename.endsWith(suffix)) filename
else filename+suffix
}
val res1 = makeSuffix(".jpg")("test")
val res2 = makeSuffix(".jpg")("test.jpg")
println(s"res1 = $res1 , res2 = $res2")
-
返回的匿名函数和 makeSuffix (suffix string) 的 suffix 变量 组合成一个闭包,因为 返回的函数引用到suffix这个变量
-
我们体会一下闭包的好处,如果使用传统的方法,也可以轻松实现这个功能,但是传统方法需要每次都传入 后缀名,比如 .jpg ,而闭包因为可以保留上次引用的某个值,所以我们传入一次就可以反复使用。大家可以仔细的体会一把!
七、函数柯里化(curry)
1、基本介绍
-
函数编程中,接受多个参数的函数都可以转化为接受单个参数的函数,这个转化过程就叫柯里化
-
柯里化就是证明了函数只需要一个参数而已。其实我们刚才的学习过程中,已经涉及到了柯里化操作。
-
不用设立柯里化存在的意义这样的命题。柯里化就是以函数为主体这种思想发展的必然产生的结果。(即:柯里化是面向函数思想的必然产生结果)
2、实例
object FunctionTest {
def main(args: Array[String]): Unit = {
// 编写一个函数,接收两个整数,可以返回两个数的乘积,要求:
val n1 = 10
val n2 = 20
println(mul1(n1,n2))
println(mul2(n1)(n2))
println(mul3(n1)(n2))
}
// 使用常规的方式完成
def mul1(n1:Int,n2 :Int):Int={
n1 * n2
}
// 使用闭包的方式完成
def mul2(n1:Int)=(n2:Int)=>{
n1 * n2
}
// 使用函数柯里化完成
def mul3(n1:Int)(n2:Int) = n1 * n2
}
3、比较两个字符串在忽略大小写的情况下是否相等,注意,这里是两个任务:
全部转大写(或小写)
比较是否相等
针对这两个操作,我们用一个函数去处理的思想,其实也变成了两个函数处理的思想(柯里化)
方式一、
//方式1: 简单的方式,使用一个函数完成.
def eq2(s1: String)(s2: String): Boolean = {
s1.toLowerCase == s2.toLowerCase
}
方式2:使用稍微高级的用法(隐式类)
object FunctionTest {
def main(args: Array[String]): Unit = {
// 比较两个字符串在忽略大小写的情况下是否相等,
val s1 = "a"
val s2 = "b"
//
val b2 = s1.checkEq(s2)(eq)
println(b2)
//下面三种写法等价,并且可以表示一个演变过程
s1.checkEq(s2)((s1:String,s2: String) =>s1.equals(s2))
s1.checkEq(s2)((s1,s2) =>s1.equals(s2))
s1.checkEq(s2)(_.equals(_))
}
//接收两个字符串,比较是否相等
def eq(s1: String, s2: String): Boolean = {
s1.equals(s2)
}
// 隐式类,
// TestEq(s: String),字符串可以调用该隐式类中的方法
implicit class TestEq(s: String) {
// 接收一个String值,
// 将比较字符串分散成两步执行
// checkEq(ss: String)完成将字符串完成大小写转换任务
// f 接收两个字符串,完成比较字符串的任务
def checkEq(ss: String)(f: (String, String) => Boolean): Boolean = {
f(s.toLowerCase, ss.toLowerCase)
}
}
}
八、控制抽象
1、控制抽象基本介绍
(1)控制抽象是这样的函数,满足如下条件
-
参数是函数
-
函数参数没有输入值也没有返回值
def myRunInThread(f1: () => Unit) = {
new Thread {
override def run(): Unit = {
f1()
}
}.start()
}
myRunInThread {
() => println("干活咯!5秒完成...")
Thread.sleep(5000)
println("干完咯!")
}
(2)上例简化处理,省略(),如下形式
def myRunInThread(f1: => Unit): Unit = {//说明
new Thread {
override def run(): Unit = {
f1
}
}.start()
}
myRunInThread {
println("干活咯!5秒完成...")
Thread.sleep(5000)
println("干完咯!")
}
2、进阶用法:实现类似while的until函数
var x = 10
def until(condition: => Boolean)(block: => Unit): Unit = {
//类似while循环,递归
if (!condition) {
block
until(condition)(block)
}
}
until(x == 0) {
x -= 1
println("x=" + x)
}