一个集合val list = List(1,2,3,4,"abc")，完成如下要求
1) 将集合list中的所有数字+1，并返回一个新的集合
2) 要求忽略掉非数字的元素，即返回的新的集合形式为(2,3,4,5)
object boke_demo01 {
def main(args: Array[String]): Unit = {
//思路1 filter + map 方式解决
//虽然可以解决问题，但是麻烦.
val list = List(1, 2, 3, 4, "hello")
// 先过滤，再map
println(list.filter(f1).map(f3).map(f2))
//思路2-模式匹配
//小结：虽然使用模式匹配比较简单，但是不够完美
val list2 = list.map(addOne2)
println("list2=" + list2)
}
//模式匹配
def addOne2(i: Any): Any = {
i match {
case x: Int => x + 1
case _ =>
}
}
def f1(n: Any): Boolean = {
n.isInstanceOf[Int]
}
def f2(n: Int): Int = {
n + 1
}
//将Any->Int [map]
def f3(n: Any): Int = {
n.asInstanceOf[Int]
}
}
－使用偏函数解决前面的问题
－案例演示
object boke_demo01 {
def main(args: Array[String]): Unit = {
//使用偏函数解决
val list = List(1, 2, 3, 4, "hello")
//定义一个偏函数
//1. PartialFunction[Any,Int] 表示偏函数接收的参数类型是Any,返回类型是Int
//2. isDefinedAt(x: Any) 如果返回true ,就会去调用 apply 构建对象实例,如果是false,过滤
//3. apply 构造器 ,对传入的值 + 1,并返回（新的集合）
val partialFun = new PartialFunction[Any, Int] {
override def isDefinedAt(x: Any) = {
println("x=" + x)
x.isInstanceOf[Int]
}
override def apply(v1: Any) = {
println("v1=" + v1)
v1.asInstanceOf[Int] + 1
}
}
//使用偏函数
//说明：如果是使用偏函数，则不能使用map,应该使用collect
//说明一下偏函数的执行流程
//1. 遍历list所有元素
//2. 然后调用 val element = if(partialFun-isDefinedAt(list单个元素)) {partialFun-apply(list单个元素) }
//3. 每得到一个 element,放入到新的集合，最后返回
val list2 = list.collect(partialFun)
println("list2" + list2)
}
}
1) 使用构建特质的实现类(使用的方式是PartialFunction的匿名子类)
2) PartialFunction是个特质
3) 构建偏函数时，参数形式[Any,Int]是泛型，第一个表示参数类型，第二个表示返回参数
4) 当使用偏函数时，会遍历集合的所有元素，编译器执行流程时先执行isDefinedAt()，如果为true，就会执行apply，构建一个新的对象返回
5) 执行isDefinedAt()为false就过滤掉这个元素，即不构建新的Int对象
6) map函数不支持偏函数，因为map底层的机制就是所有循环遍历，无法过滤处理原来集合的元素
7) collect函数支持偏函数
object boke_demo01 {
def main(args: Array[String]): Unit = {
//可以将前面的案例的偏函数简写
def partialFun: PartialFunction[Any, Int] = {
//简写成case 语句
case i: Int => i + 1
case j: Double => (j * 2).toInt
}
val list = List(1, 2, 3, 4, 1.2, 2.4, 1.9f, "hello")
val list2 = list.collect(partialFun)
println("list2=" + list2)
//第二种简写形式
val list3 = list.collect {
case i: Int => i + 1
case j: Double => (j * 2).toInt
case k: Float => (k * 3).toInt
}
println("list3=" + list3) // (2,3,4,5)
}
}
函数作为一个变量传入到另一个函数中，那么该作为参数的函数的类型是：function1，即：(参数类型) => 返回类型
object boke_demo01 {
def main(args: Array[String]): Unit = {
def plus(x: Int) = 3 + x
//说明
val result = Array(1, 2, 3, 4).map(plus(_))
println(result.mkString(",")) //4,5,6,7
//说明
//1. 在scala中，函数也是有类型，比如plus就是 <function1>
println("puls的函数类型function1" + (plus _))
}
}
1) map(plus(_))中的plus(_)就是将plus这个函数当作一个参数传给了map，_这里代表从集合中遍历出来的一个元素
2) plus(_)这里也可以写成plus表示对Array(1,2,3,4)遍历，将每次遍历的元素传给plus的x
3) 进行 3+x 运算后，返回新的Int，并加入到新的集合result中
4) def map[B,That](f:A=>B)的声明中的 f:A=>B 的一个函数
没有名字的函数就是匿名函数，可以通过函数表达式来设置匿名函数
object boke_demo01 {
def main(args: Array[String]): Unit = {
//对匿名函数的说明
//1. 不需要写 def 函数名
//2. 不需要写返回类型，使用类型推导
//3. = 变成 =>
//4. 如果有多行，则使用{} 包括
val triple = (x: Double) => {
println("x=" + x)
3 * x
}
println("triple＝" + triple(3)) // 9.0
}
}
能够接受函数作为参数的函数，叫做高阶函数(higher-order function)。可使应用程序更加健壮
object boke_demo01 {
def main(args: Array[String]): Unit = {
def test(f: Double => Double, f2: Double => Int, n1: Double) = {
f(f2(n1)) // f(0)
}
//sum 是接收一个Double,返回一个Double
def sum(d: Double): Double = {
d + d
}
def mod(d: Double): Int = {
d.toInt % 2
}
val res = test(sum, mod, 5.0) //
println("res=" + res) // 2.0
}
}
object boke_demo01 {
def main(args: Array[String]): Unit = {
//说明
//1. minusxy是高阶函数,因为它返回匿名函数
//2. 返回的匿名函数 (y: Int) => x - y
//3. 返回的匿名函数可以使用变量接收
def minusxy(x: Int) = {
(y: Int) => x - y //匿名函数
}
//分步执行
//f1 就是 (y: Int) => 3 - y
val f1 = minusxy(3)
println("f1的类型=" + f1)
println(f1(1)) // 2
println(f1(9)) // -6
//也可以一步到位的调用
println(minusxy(4)(9)) // -5
}
}
参数推断省去类型信息(在某些情况下[需要有应用场景]，参数类型是可以推断出来的，如list=(1,2,3) list.map() map中函数参数类型是可以推断的)，同时也可以进行相应的简写
1) 参数类型是可以推断时，可以省略参数类型
2) 当传入的函数，只有单个参数时，可以省去括号
3) 如果变量只在=>右边只出现一次，可以用_来代替
object boke_demo01 {
def main(args: Array[String]): Unit = {
val list = List(1, 2, 3, 4)
println(list.map((x: Int) => x + 1)) //(2,3,4,5)
println(list.map((x) => x + 1)) //(2,3,4,5)
println(list.map(x => x + 1)) //(2,3,4,5)
println(list.map(_ + 1)) //(2,3,4,5)
println(list.reduce(f1)) // 10
println(list.reduce((n1: Int, n2: Int) => n1 + n2)) //10
println(list.reduce((n1, n2) => n1 + n2)) //10
println(list.reduce(_ + _)) //10
val res = list.reduce(_ + _)
}
def f1(n1: Int, n2: Int): Int = {
n1 + n2
}
}
闭包就是一个函数和与其相关的引用环境组合的一个整体(实体)
object boke_demo01 {
def main(args: Array[String]): Unit = {
//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
}
}
－对上述案例演示的小结和说明
1) (y: Int) => x - y 返回的是一个匿名函数，因为该函数引用到函数外的x，那么该函数和x整体形成一个闭包。如：这里val f = minusxy(20)的f函数就是闭包
2) 可以这样理解，返回函数是一个对象，而x就是该对象的一个字段，它们共同形成一个闭包
3) 当多次调用f时(可以理解多次调用闭包)，发现使用的是同一个x，所以x不变
4) 在使用闭包时，主要搞清楚返回函数引用了函数外的哪些变量，因为它们会组合成一个整体(实体)，形成一个闭包
object boke_demo01 {
def main(args: Array[String]): Unit = {
/*
请编写一个程序，具体要求如下
1.编写一个函数 makeSuffix(suffix: String) 可以接收一个文件后缀名(比如.jpg)，并返回一个闭包
2.调用闭包，可以传入一个文件名，如果该文件名没有指定的后缀(比如.jpg) ,则返回 文件名.jpg , 如果已经有.jpg后缀，则返回原文件名。
比如 文件名 是 dog =>dog.jpg
比如 文件名 是 cat.jpg => cat.jpg
3.要求使用闭包的方式完成
提示：String.endsWith(xx)
*/
//使用并测试
val f = makeSuffix(".jpg")
println(f("dog.jpg")) // dog.jpg
println(f("cat")) // cat.jpg
}
def makeSuffix(suffix: String) = {
//返回一个匿名函数，回使用到suffix
(filename:String) => {
if (filename.endsWith(suffix)) {
filename
} else {
filename + suffix
}
}
}
}
1) 函数编程中，接受多个参数的函数都可以转化为接受单个参数的函数，这个转化过程就叫柯里化
2) 柯里化就是证明了函数只需要一个参数而已
//编写一个函数,接收两个整数,可以返回两个数的乘积,要求: //使用常规的方式完成 //使用闭包的方式完成 //使用函数柯里化完成 def mul(x: Int, y: Int) = x * y println(mul(10, 10)) def mulCurry(x: Int) = (y: Int) => x * y println(mulCurry(10)(9)) def mulCurry2(x: Int)(y:Int) = x * y println(mulCurry2(10)(8))
object boke_demo01 {
def main(args: Array[String]): Unit = {
//这是一个函数，可以接收两个字符串，比较是否相等
def eq(s1: String, s2: String): Boolean = {
s1.equals(s2)
}
//隐式类
implicit class TestEq(s: String) {
//体现了将比较字符串的事情，分解成两个任务完成
//1. checkEq 完转换大小写
//2. f函数完成比较任务
def checkEq(ss: String)(f: (String, String) => Boolean): Boolean = {
f(s.toLowerCase, ss.toLowerCase)
}
}
val str1 = "hello"
println(str1.checkEq("HeLLO")(eq))
//在看一个简写形式
println(str1.checkEq("HeLLO")(_.equals(_)))
}
}
//如何实现将一段代码(从形式上看)，作为参数传递给高阶函数，在高阶函数内部执行这段代码
//其使用的形式如 breakable{}
var n = 10
breakable {
while (n <= 20) {
n += 1
if (n == 18) {
break()
}
}
}
－控制抽象是这样的函数，满足如下条件
1) 参数是函数
2) 函数参数没有输入值也没有返回值
－控制抽象应用案例(使用控制抽象实现了while语法)
object boke_demo01 {
def main(args: Array[String]): Unit = {
//myRunInThread 就是一个抽象控制
//是没有输入，也没有输出的函数 f1: () => Unit
def myRunInThread(f1: () => Unit) = {
new Thread {
override def run(): Unit = {
f1() //只写了 f1
}
}.start()
}
myRunInThread {
() =>
println("干活咯！5秒完成...")
Thread.sleep(5000)
println("干完咯！")
}
//简写形式
def myRunInThread2(f1: => Unit) = {
new Thread {
override def run(): Unit = {
f1 //只写了 f1
}
}.start()
}
//对于没有输入，也没有返回值函数，可以简写成如下形式
myRunInThread2 {
println("干活咯！5秒完成...~~~")
Thread.sleep(5000)
println("干完咯！~~~")
}
}
}
object boke_demo01 {
def main(args: Array[String]): Unit = {
var x = 10
//说明
//1 函数名为 until , 实现了类似 while循环的效果
//2. condition: => Boolean 是后一个没有输入值，返回Boolean类型函数
//3. block: => Unit 没有输入值，也没有返回值
def mywhile(condition: => Boolean)(block: => Unit): Unit = {
//类似while循环，递归
if (!condition) {
block // x= 9 ,x = 8 x =7 ....
mywhile(condition)(block)
}
}
mywhile(x == 0) {
x -= 1
println("x=" + x)
}
}
}
原文：https://www.cnblogs.com/zhanghuicheng/p/10876998.html