当前位置：首页 > news >正文

scala05-函数式编程02

news 来源：原创 2024/5/9 4:11:31

函数式编程-函数对象作为方法的参数

package com.zishi.scala.a02.okk05/*** 将函数对象作为方法的参数来使用，* 函数本身就是对象，* 对象的使用领域：变量，方法参数，返回值类型** 类比Java* public void test(User user) {* }** User user = new User();** test(user); 对象作为方法的参数* test(new User());*/
object Test05_Lambda01 {def main(args: Array[String]): Unit = {// 创建方法对象def fun33(age: Int): String = {"Hello:" + age}/***  等同于*  def test(f: Function1[Int, String]) : Unit = {}*/def test(f: (Int) => String): Unit = {println(f(23))}val f2 = fun33 _test(f2) // Hello:23def sum(x:Int, y:Int): Int = {x + y}def sub(x: Int, y: Int): Int = {x - y}def test2(fun: (Int, Int) => Int): Unit = {val i = fun(10, 20)println(i)}// 将函数名称作为参数传递为一个函数作为参数，此时不需要下划线test2(sum)//TODO: 这里函数的名称sub真的很重要吗？// 类比Java：test(new User())test2(sub)// TODO： 将参数传递的名字取消掉// 如果函数声明没有def和名称，那么就是匿名函数test2((x: Int, y: Int) => {x * y})// 将匿名函数赋值给一个变量val a = (x: Int, y: Int) => {x / y}test2(a)// 匿名函数的简化原则//(1)参数的类型可以省略，会根据形参进行自动的推导test2((x, y) => {x * y})//(2)类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。//(3)匿名函数如果只有一行，则大括号也可以省略test2((x, y) => x * y)//(4)如果参数只出现一次,并且按照顺序执行一次，则参数省略且后面参数可以用_代替println("-------------------")test2(_ * _) // 下划线类似占位符，第一个下划线代表第一个参数，依次类推//(5) 如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线// 定义一个函数，以函数作为参数输入def f(func: String => Unit): Unit = {func("abcde")}f((name: String) => {println(name)})println("========================")// 匿名函数的简化原则//(1)参数的类型可以省略，会根据形参进行自动的推导f((name) => {println(name)})//(2)类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。f(name => {println(name)})//(3)匿名函数如果只有一行，则大括号也可以省略f(name => println(name))//(4) 如果参数只出现一次，则参数省略且后面参数可以用_代替f(println(_))//(5) 如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线f(println _)f(println)}
}

练习

package com.zishi.scala.a02.okk05object Test05_Lambda02 {def main(args: Array[String]): Unit = {// 实际示例，定义一个”二元运算“函数，只操作1和2两个数，但是具体运算通过参数传入def dualFunctionOneAndTwo(fun: (Int, Int) => Int): Int = {fun(1, 2)}val add = (a: Int, b: Int) => a + bval minus = (a: Int, b: Int) => a - bprintln(dualFunctionOneAndTwo(add))println(dualFunctionOneAndTwo(minus))// 匿名函数简化println(dualFunctionOneAndTwo((a: Int, b: Int) => a + b))println(dualFunctionOneAndTwo((a: Int, b: Int) => a - b))println(dualFunctionOneAndTwo((a, b) => a + b))println(dualFunctionOneAndTwo(_ + _))println(dualFunctionOneAndTwo(_ - _))println(dualFunctionOneAndTwo((a, b) => b - a))println(dualFunctionOneAndTwo(-_ + _))// Java里面存在引用类型和基本类型同时作为方法的参数 void test(int x, User u);// 类比javadef cal(x: Int, func: (Int, Int) => Int, y: Int) = {func(x, y)}def sum(x: Int, y: Int) = {x + y}println("....")println(cal(3,(x: Int, y: Int) => {x + y}, 5))println(cal(3, (x: Int, y: Int) => x + y, 5))println(cal(3, (x, y) => x + y, 5))println(cal(3, _ + _, 5))}
}

函数作为返回值

package com.zishi.scala.a02.okk05/*** 函数作为返回值返回* 类比Java* public User test() {* User user = new User();* return user;* }** public User test() {* return new User();* }*/
object Test05_Lambda03 {def main(args: Array[String]): Unit = {// 函数作为返回值返回def outer() = {def inner(): Unit = {print("abc")}inner _}val f1 = outer()f1()//下面的调用更诡异outer()() // abcprintln("...............")def outer2() = {//def inner(name: String): Unit = print(s"abc${name}")def inner(name: String): Unit = print(s"abc${name}")inner _}val f2 = outer2()f2("aege") // abcabcaegedef outer3(x: Int) = {def mid(f : (Int, Int) => Int) = {def inner(y: Int) = {f(x, y)}inner _}mid _}println()val mid = outer3(1)val inner = mid( _ + _)val res = inner(3)println(res)val res2 = outer3(1)( _ + _)(3)println(res2)}
}

高阶函数01

package com.zishi.scala.a02.okk05object Test06_HighOrderFunction01 {def main(args: Array[String]): Unit = {def f(n: Int): Int = {println("f调用")n + 1}val result: Int = f(123)println(result) // 124// 1. 函数作为值进行传递val f1: Int => Int = fval f2 = f _println(f1) // com.zishi.scala.okk05.Test06_HighOrderFunction$$$Lambda$16/0x00000008000d7040@1e67a849println(f1(12)) // 13println(f2) // com.zishi.scala.okk05.Test06_HighOrderFunction$$$Lambda$17/0x00000008000d6840@57d5872cprintln(f2(35)) // 36def fun(): Int = {println("fun调用")1}val f3: () => Int = funval f4 = fun _println(f3) // com.zishi.scala.okk05.Test06_HighOrderFunction$$$Lambda$18/0x00000008000d6040@64c87930println(f4) // com.zishi.scala.okk05.Test06_HighOrderFunction$$$Lambda$19/0x00000008000d6440@400cff1a}
}

高阶函数02


object Test06_HighOrderFunction02 {def main(args: Array[String]): Unit = {// 2. 函数作为参数进行传递// 定义二元计算函数def dualEval(op: (Int, Int) => Int, a: Int, b: Int): Int = {op(a, b)}def add(a: Int, b: Int): Int = {a + b}println(dualEval(add, 12, 35))println(dualEval((a, b) => a + b, 12, 35))println(dualEval(_ + _, 12, 35))// 3. 函数作为函数的返回值返回def f5(): Int => Unit = {def f6(a: Int): Unit = {println("f6调用 " + a)}f6 // 将函数直接返回}//    val f6 = f5()//    println(f6)//    println(f6(25))println(f5()(25))}
}object Test06_HighOrderFunction03 {def main(args: Array[String]): Unit = {// 3. 函数作为函数的返回值返回def f5(): Int => Unit = {def f6(a: Int): Unit = {println("f6调用 " + a)}f6 // 将函数直接返回}//    val f6 = f5()//    println(f6)//    println(f6(25))println(f5()(25))}
}

练习

package com.zishi.scala.a02.okk05/*** 函数作为返回值*/
object Test08_Practice {def main(args: Array[String]): Unit = {// 2. 练习2def func(i: Int): String => (Char => Boolean) = {def f1(s: String): Char => Boolean = {def f2(c: Char): Boolean = {if (i == 0 && s == "" && c == '0') false else true}f2}f1}println(func(0)("")('0'))//falseprintln(func(0)("")('1'))//trueprintln(func(23)("")('0'))//trueprintln(func(0)("hello")('0'))//true// 匿名函数简写def func1(i: Int): String => (Char => Boolean) = {s => c => if (i == 0 && s == "" && c == '0') false else true}println(func1(0)("")('0'))//falseprintln(func1(0)("")('1'))//trueprintln(func1(23)("")('0'))//trueprintln(func1(0)("hello")('0'))//true// 柯里化def func2(i: Int)(s: String)(c: Char): Boolean = {if (i == 0 && s == "" && c == '0') false else true}println(func2(0)("")('0'))//falseprintln(func2(0)("")('1'))//trueprintln(func2(23)("")('0'))//trueprintln(func2(0)("hello")('0'))//true}
}object Test08_Practice01 {def main(args: Array[String]): Unit = {// 1. 练习1val fun = (i: Int, s: String, c: Char) => {if (i == 0 && s == "" && c == '0') false else true}println(fun(0, "", '0'))//falseprintln(fun(0, "", '1'))//trueprintln(fun(23, "", '0'))//trueprintln(fun(0, "hello", '0'))//true}
}