Scala-函数的高阶使用

最新推荐文章于 2023-01-26 15:31:14 发布
最新推荐文章于 2023-01-26 15:31:14 发布
阅读量506 收藏
点赞数
文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clearlxj/article/details/119001905
版权

函数高级

高阶函数

在 Scala 中,函数是一等公民，对于一个函数我们可以:定义函数、调用函数

高阶运用：

1、函数可以作为值进行传递

object TestFunction {

    def main(args: Array[String]): Unit = {

        def f(n: Int): Int = {
            println("f被调用啦")
            n + 1
        }

        val result = f(123)
        println(result) // 124

        val f1: Int => Int = f
        val f2 = f _
        println(f1)      // 函数的引用地址
        println(f1(100)) // 101
        println(f2(200)) // 201
        
        
        def fun(): Int = {
            println("fun被调用啦")
            1
        }
        
        val f3 = fun _
        val f4: () => Int = fun
    }
}

2、函数可以作为参数进行传递

object TestFunction {

    def main(args: Array[String]): Unit = {
        // 定义二元计算函数
        def dualEval(op: (Int, Int) => Int, a: Int, b: Int): Int = {
            op(a, b)
        }

        def add (a: Int, b: Int) : Int = {
            a + b
        }

        dualEval(add, 12, 15)
        dualEval((a, b) => a + b, 12, 15)
    }
}

3、函数可以作为函数返回值返回

object TestFunction {

    def main(args: Array[String]): Unit = {

        def f5(): Int => Unit = {
            def f6 (a: Int): Unit = {
                println("f6备调用啦" + a)
            }
            f6 // 将函数直接返回
        }

        val f6 = f5()
        println(f6) // 得到的是f6的引用
        println(f6(123)) // f6备调用啦123
        println(f5()(25)) // f6备调用啦25
    }
}

实例

object TestPractice {

    def main(args: Array[String]): Unit = {

        // 定义一个匿名函数,并将它作为值赋给变量 fun。函数有三个参数,类型分别为 Int,String,Char,返回值类型为 Boolean。
        // 要求调用函数 fun(0, “”, ‘0’)得到返回值为 false,其它情况均返回 true。
        val fun = (i: Int, s: String, c: Char) => { if (i == 0 && s == "" && c == '0') false else true }

        println(fun(0, "", '0'))  // false
        println(fun(1, "", '0'))  // true
        println(fun(0, "1", '0')) // true
        println(fun(0, "", '1'))  // true
        println(fun(1, "1", '1')) // true


        // 定义一个函数 func,它接收一个 Int 类型的参数,返回一个函数(记作 f1)。
        // 它返回的函数 f1,接收一个 String 类型的参数,同样返回一个函数(记作 f2)。
        // 函数 f2 接收一个 Char 类型的参数,返回一个 Boolean 的值。
        // 要求调用函数 func(0) (“”) (‘0’)得到返回值为 false,其它情况均返回 true。
        def 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'))  // false
        println(func(1)("")('0'))  // true
        println(func(0)("1")('0')) // true
        println(func(0)("")('1'))  // true
        println(func(1)("1")('1')) // true
        
        // 匿名函数的简写
        def func1(i: Int): String => (Char => Boolean) = {
            s => c => if (i == 0 && s == "" && c == '0') false else true
        }

        // 柯里化
        def func2(i: Int)(s: String)(c: Char): Boolean = {
            if (i == 0 && s == "" && c == '0') false else true
        }
    }
}

匿名函数

没有名字的函数就是匿名函数。

(x: Int) => {函数体}

x:表示输入参数类型;Int:表示输入参数类型;函数体:表示具体代码逻辑

传递匿名函数至简原则:

(1)参数的类型可以省略,会根据形参进行自动的推导

(2)类型省略之后,发现只有一个参数,则圆括号可以省略;其他情况:没有参数和参数超过 1 的永远不能省略圆括号。

(3)匿名函数如果只有一行,则大括号也可以省略

(4)如果参数只出现一次,则参数省略且后面参数可以用_代替

object TestLambda {

    def main(args: Array[String]): Unit = {

        val fun = (name: String) => { println(name) }
        fun("test") // test

        // 定义一个函数，以函数作为参数输入
        def f(func: String => Unit): Unit = {
            func("testF")
        }

        f(fun) // testF
        f((name: String) => { println(s"---$name") }) // ---testF

        // (1)参数的类型可以省略,会根据形参进行自动的推导
        f((name) => { println(s"---$name") })

        // (2)类型省略之后,发现只有一个参数,则圆括号可以省略; 其他情况:没有参数和参数超过1的永远不能省略圆括号。
        f(name => { println(s"---$name") })

        // (3)匿名函数如果只有一行,则大括号也可以省略
        f(name => println(s"---$name"))

        // (4)如果参数只出现一次,则参数省略且后面参数可以用_代替
        f(println(_))

        // (5)如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线
        f(println)
        
        // 实例，定义一个二元运算函数，只操作1和2，但是具体的运算通过参数传入
        def dualFunctionOneAndTwo(fun: (Int, Int) => Int): Unit = {
            fun(1, 2)
        }

        val add = (a: Int, b:Int) => a + b
        val minus = (a: Int, b:Int) => a - b

        dualFunctionOneAndTwo(add)
        dualFunctionOneAndTwo(minus)

        // 简化：
        dualFunctionOneAndTwo((a: Int, b: Int) => a + b)
        dualFunctionOneAndTwo((a, b) => a + b)
        dualFunctionOneAndTwo(_ + _)
    }
}

高阶函数案例

Map映射

object TestPracticeCollection {

    def main(args: Array[String]): Unit = {

        val arr: Array[Int] = Array(1, 11, 111, 1111)

        // 对数组进行处理，讲操作抽象出来，处理完毕的结果返回一个新的数组
        def arrayOperation(array: Array[Int], op: Int => Int): Array[Int] = {
            for (elem <- array) yield op(elem)
        }

        // 定义一个加1操作
        def addOne(a : Int): Int = {
            a + 1
        }

        // 调用函数
        val newArray = arrayOperation(arr, addOne)
        println(newArray.mkString(",")) // 2,12,112,1112

        // 调用匿名函数
        val newArray2 = arrayOperation(arr, (a) => a * 2)
        println(newArray2.mkString(",")) // 2,22,222,2222
    }
}

函数柯里化&闭包

闭包:函数式编程的标配

闭包:如果一个函数,访问到了它的外部(局部)变量的值,那么这个函数和他所处的环境,称为闭包

函数柯里化:把一个参数列表的多个参数,变成多个参数列表。

object TestClosureAndCurrying {
    def main(args: Array[String]): Unit = {

        def add(a: Int, b: Int): Int = {
            a + b
        }

        // 1.考虑固定一个加数的场景
        def addByFour(b: Int): Int = {
            4 + b
        }

        // 2.拓展固定加数改变的情况
        def addFive(b: Int): Int = {
            5 + b
        }

        // 3.将固定加数作为另一个参数传入，但是是作为“第一层参数”传入
        def addByFour1(): Int => Int = {
            def addB(b: Int): Int = {
                4 + b
            }

            addB
        }

        def addByA(a: Int): Int => Int = {
            def addB(b: Int): Int = {
                a + b
            }

            addB
        }

        val addByFour2 = addByA(4)
        val addByFive2 = addByA(5)
        println(addByFour2(15)) // 19
        println(addByFive2(10)) // 15

        // 4.addByA 的Lambda表达式
        def addByA1(a: Int): Int => Int = {
            (b: Int) => {
                a + b
            }
        }
        def addByA2(a: Int): Int => Int = {
            b => a + b
        }
        def addByA3(a: Int): Int => Int = a + _

        val addByFour3 = addByA(4)
        val addByFive3 = addByA(5)
        println(addByFour3(15)) // 19
        println(addByFive3(10)) // 15

        // 5.柯里化
        def addByCurrying(a: Int)(b: Int):Int = { a + b }
        println(addByCurrying(12)(13)) // 25
    }
}

递归

一个函数/方法在函数/方法体内又调用了本身,我们称之为递归调用，这样的函数就叫做递归函数

递归算法

  1. 方法调用自身

  2. 方法必须要有跳出的逻辑

  3. 方法调用自身时,传递的参数应该有规律

  4. scala 中的递归必须声明函数返回值类型

object TestRecursion {
    def main(args: Array[String]): Unit = {
        println(fact(5)) // 120
    }

    // 递归实现阶乘
    def fact(i: Int): Int = {
        if (i == 0) {
            // 0! = 1
            // 只有最后一行代码的return可以省略
            return 1
        }
        fact(i - 1) * i
    }

    // 尾递归实现
    def tailFact(n: Int): Int = {
        // 这个注解当方法不是尾递归方法时会报错
        @tailrec
        def loop(n: Int, result: Int): Int = {
            if (n == 0) return result
            loop(n - 1, result * n)
        }

        loop(n, 1)
    }
}

递归会耗费更多的栈空间资源，有可能会导致栈溢出。尾递归的话，每次递归会将上次递归调用弹出，并将本次调用压入。

控制抽象

1、值调用（传值参数）：把计算后的值传递过去

2、名调用（传名参数）：把代码传递过去

Java 只有值调用;Scala 既有值调用,又有名调用

object TestControlAbstraction {

    def main(args: Array[String]): Unit = {

        // 1.传值参数
        def f0 (a: Int): Unit = {
            println("a: " + a)
        }

        f0(123) // a: 123

        def f1(): Int = {
            println("f1被调用")
            12
        }
        f0(f1()) // a: 12

        // 2.传名参数，参数不再是具体的值，而是代码块，这里的代码块的返回值是Int
        def f2 (b: => Int): Unit = {
            println("b: " + b)
            println("b: " + b)
        }

        f2(23)
        // f1将会被调用两次，因为这里我们把b就直接当前成了f1()来使用了，因此名传递是将代码块直接传递进去
        // f1被调用
        // b: 12
        // f1被调用
        // b: 12
        f2(f1())
        // 代码块会被调用两次，并且返回值是129
        // 这里是一个代码块
        // b: 129
        // 这里是一个代码块
        // b: 129
        f2({
            println("这里是一个代码块")
            129
        })
    }
}

自定义一个while循环

object TestMyWhile {

    def main(args: Array[String]): Unit = {
        var n = 10

        // 1.常规的while循环
        while (n >= 1) {
            println(n)
            n -= 1
        }

        // 2.用闭包实现一个函数，将代码块作为参数传入，递归调用
        def myWhile(condition: => Boolean): (=> Unit) => Unit = {
            // 内层函数需要递归调用，参数就是循环体
            def doLoop(op: => Unit): Unit = {
                if (condition) {
                    op
                    myWhile(condition)(op)
                }
            }
            doLoop _
        }

        n = 10
        myWhile(n >= 1) {
            println(n)
            n -= 1
        }

        // 3.用匿名函数实现
        def myWhile2(condition: => Boolean): (=> Unit) => Unit = {
            // 内层函数需要递归调用，参数就是循环体
            op => {
                if (condition) {
                    op
                    myWhile2(condition)(op)
                }
            }
        }

        n = 10
        myWhile2(n >= 1) {
            println(n)
            n -= 1
        }

        // 4，用柯里化实现
        def myWhile3(condition: => Boolean)(op: => Unit):Unit = {
            // 内层函数需要递归调用，参数就是循环体
            if (condition) {
                op
                myWhile3(condition)(op)
            }
        }

        n = 10
        myWhile3(n >= 1) {
            println(n)
            n -= 1
        }
    }
}

惰性加载

当函数返回值被声明为 lazy 时,函数的执行将被推迟,直到我们首次对此取值,该函数才会执行。这种函数我们称之为惰性函数。这种加载方式称之为惰性加载。

lazy 不能修饰 var 类型的变量

object TestLazy {

    def main(args: Array[String]): Unit = {

        lazy val result: Int = sum(13, 47)
        println("1.函数调用")
        println("2.result = " + result)
        println("4.result = " + result)

        def sum(a: Int, b: Int): Int = {
            println("3. sum被调用了")
            a + b
        }
    }
}

// 结果如下：
1.函数调用
3. sum被调用了
2.result = 60
4.result = 60
魔笛Love
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
scala的高阶函数(算子)
m0_59737088的博客
08-04 598
scala的高阶函数（算子） scala简介 1.Scala是一门多范式的静态类型编程语言,Scala支持【面向对象】和【函数式编程】 2.Scala源代码(.scala)会被编译成java字节码(.class)，然后运行在JVM之上，并可以调用现有的Java类库，实现两种语言的无缝对接 Scala匿名函数 知识补充： 1.不需要写def 函数名 2.不需要写返回类型，使用类型推导 3.= 变成 => 4. 如果有多行则使用{}包括，否则建议省略 //普通的函数 def test1(v
Scala 函数式编程_函数是Scala中的一等公民
weixin_34224941的博客
04-24 476
2019独角兽企业重金招聘Python工程师标准>>> ...
scala答疑
myself_ning的博客
08-14 247
关于scala编程的疑问，scala bug， scala理解 相关的解答。
Scala获取main函数参数，idea演示
06-09 2035
1 代码示范 /** * @author zhangjin * @create 2019-06-09 11:15 */ object TestMarnArgs { def main(args: Array[String]): Unit = { // 检验参数 if (args.length != 2) { pr...
快学Scala第12章----高阶函数
大冰的小屋
06-26 1158
本章要点 在Scala中函数是“头等公民”，就和数字一样； 你可以创建匿名函数，通常还会把它们交给其他函数； 函数参数可以给出需要稍后执行的行为； 许多集合方法都接受函数参数，将函数应用到集合中的值； 有很多语法上的简写让你以简短且易读的方式表达函数参数； 你可以创建操作代码块的函数，它们看上去就像是内建的控制语句。 作为值的函数在Scala中，你可以在变量中存放函数：import scala.ma
scala-rate-limiter:使用高阶函数测试速率限制
07-01
但是使用正确的隐式，你应该能够让它为最多 22 个参数的函数工作。 import nl . flotsam . rate . _ import scala . concurrent . _ import scala . concurrent . duration . _ // For sake of example, we're ...
scala-2.12.10.zip
12-24
Scala的语法优雅且富有表达力，它允许开发者使用函数式编程的特性，如高阶函数、柯里化、模式匹配和不可变数据结构，同时保留了面向对象的类、接口和继承。这使得Scala成为处理大数据、并发和分布式计算的理想选择，...
scala-2.12.14.zip&scala-2.12.11.tgz Linux版本压缩包.rar
06-27
3. **函数式编程**：支持高阶函数、柯里化、尾递归优化等特性，使得代码简洁且易于测试。 4. ** Actors模型**：提供了一种轻量级的并发机制，用于实现高效的并行和分布式计算。 5. **集合库**：Scala的集合库强大且...
scala-intellij-bin-2021.3.6.zip
10-24
3. **函数式编程**：Scala支持高阶函数和闭包，可以定义匿名函数，使用map、filter、fold等函数式编程操作符。它还引入了不可变数据结构，这在并发编程中特别有用。 4. **Actor模型**：Scala内置了对Akka框架的支持...
Scala-2.11.1.zip
03-29
3. **函数式编程**：Scala是函数式编程的强大平台，它提供了高阶函数、匿名函数、柯里化、尾递归优化等功能。函数在Scala中被视为一等公民，可以作为参数传递，也可以作为返回值。 4. **集合库**：Scala的集合库是...
高阶函数 in Scala
09-20
详细讲解Scala中的高阶函数部分，具体实例剖析Scala中高阶函数的意义所在，对控制抽象进行了详细的说明，参考书籍《快学Scala》、《Programming in Scala》
Scala高阶函数
Faded1573606285的博客
10-29 210
1 作为参数的函数 函数作为一个变量传入到了另一个函数中，那么该作为参数的函数的类型是：function1，即：（参数类型） => 返回类型 def plus(x: Int) = 3 + x val result1 = Array(1, 2, 3, 4).map(plus(_)) println(result1.mkString(",")) 尖叫提示...
python 第5章 函数和代码复用
m0_67069720的博客
01-26 647
计算机二级Python—第5章 函数和代码复用
scala基础【高阶函数编程】
weixin_43923463的博客
07-19 409
所谓的高阶函数，其实就是将函数当成一个类型来使用，而不是当成特定的语法结构。主要内容包括将函数作为对象，将函数作为参数，将函数作为返回值等
Scala编程11: 高阶函数(重点掌握)
Big_data_implicit_
12-12 165
1、高阶函数 高阶函数，即定义时将参数类型设置为函数，并在定义的地方进行调用，在使用时再将需要的函数体直接写入或通过变量方式传入进去 第一种：外面定义一个函数，在使用时直接调用指向函数体的变量来调用此函数，使用起来和普通函数没太多差别，直接传值 如：交换两个数 # 先定义一个普通函数，实现两个数的交换 def swap2num(x:Double, y:Int):(Int,Double)={(y,x)} # 再将此函数赋值给一个变量, 注意后面的_不可以省略,此步也可以直接省略，直接调用也是
scala中高阶函数
迎接小天使
05-23 209
基本介绍 能够接受函数作为参数的函数，叫做高阶函数 (higher-order function)。可使应用 程序更加健壮。 高阶函数基本使用 //test 就是一个高阶函数，它可以接收f: Double => Double def test(f: Double => Double, n1: Double) = { f(n1) } //sum 是接收一个Double,返回一个Double def sum(d: Double): Double = { d + d } val
scala高阶函数
weixin_54707168的博客
01-29 419
高阶函数是指使用其他函数作为参数、或者返回一个函数作为结果的函数。在Scala中函数是“一等公民”，所以允许定义高阶函数。这里的术语可能有点让人困惑，我们约定，使用函数值作为参数，或者返回值为函数值的“函数”和“方法”，均称之为“高阶函数”。 最常见的一个例子是Scala集合类（collections）的高阶函数map val salaries = Seq(20000, 70000, 40000)val doubleSalary = (x: Int) => x * 2val newSalar
Scala 之高阶函数
v3424的博客
04-20 608
前言：常用的高阶函数： map：集合元素处理 foreach：集合元素处理 flatMap：扁平化处理 filter：过滤 groupBy：分组 sortBy：排序 scala的高阶函数mapforeachflatMapgroupByfilter/filterNotsortWith/sortByreducefold练习：基于以下List集合实现词频统计（WordCount） map map函数的语法 final def map[B](f: (A) ⇒ B): List[B] //map函数只有1个参
写段Scala复杂的高阶
最新发布
06-10
好的，以下是一个复杂的Scala代码示例，演示如何使用高阶函数和元组对一个包含学生信息的列表进行排序： ```scala object HigherOrderExample { def main(args: Array[String]) { val students = List(("Alice", ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值