Scala函数

于 2024-01-10 17:58:30 发布
阅读量1.1k 收藏 24
点赞数 35
文章标签： scala 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79020421/article/details/135509786
版权

day03 Scala函数

一、创建函数

package day01
​
object Functions {
  def main(args: Array[String]): Unit = {
    //val maxF = max _的意思是将max函数赋值给名为maxF的变量，
    //但是在这里max后面添加了一个下划线 _，表示将函数的类型转换为函数值的类型
    val maxFunc = max _
    println(maxFunc(1, 2))
    println(fac(6))
    println(getIndex(Array[Int](1, 2, 3, 4), 3))
​
  }
​
  /*1、两个值找最大值*/
  def max(a:Int,b:Int):Int = {
    if(a > b) a else b
  }
​
  /*2、取绝对值*/
  def abs(a:Int):Int = {
    // -a中的-表示前缀操作符
    if(a < 0) -a else a
  }
​
  /*3、找目标值在数组中的下标位置*/
  def getIndex(arr:Array[Int],tar:Int):Int={
    // 也是用递归，循环找数组中的值，index是数组下表
    def loop(index:Int):Int={
      // 调用loop时，将index设为0，1、从第一个数查，如果相等返回当前下标
      // 2、如果不相等，index+1作为loop参数，继续调用loop
      // 3、直到数组下标超过数组长度，返回-1
      if (index >= arr.length){
        -1
        // arr(index)表示当前下标的元素值
      }else if (arr(index) == tar){
        index
      }else {
        // 继续查找对比
        loop(index+1)
      }
    }
    loop(0)
  }
​
  /*4、阶乘,使用递归(自己调自己)*/
  def fac(a:Int):Int = {
    // 递归：自己调自己
    // acc表示结果集
    def loop(n:Int,acc:Int):Int={
      if(n ==1) acc
        // 继续调用loop，形成了循环，当n减到1，直接输出结果
        // 先输入（5，1）loop(5,1)==>loop(4,5)==>loop(3,20)==>loop(2,60)==>loop(1,120)
      else loop(n-1,acc*n)
    }
    loop(a,1)
  }
  /*阶乘的另一个方法*/
  def fac1(a:Int):Int={
    if (a ==1 ) 1 else fac1(a-1)*a
  }
​
​
  def formatAbs(num: Int): Unit = {
    val msg: String = "source data = %d,abs(num)=%d"
    println(msg.format(num, abs(num)))
  }
  def formatMax(num:Int,num2:Int):Unit={
    val msg: String="source data = %d,%d,max(num)=%d"
    println(msg.format(num,num2,max(num,num2)))
  }
}

二、高阶函数--泛化函数

当一个函数被多次调用时，我们可以将这个函数写成泛化函数

/*
  * 参数列表:1、num:Int表示输入的数字
  * 2、funcName:String一个字符串
  * 3、funct:Int=>Int 定义一个方法，输入int类型，输出int类型，方法名为funct
  *    funct表示自定义的方法名，
  *    Int表示输入的参数类型，
  *    =>表示执行函数，
  *    Int表示执行完函数返回的数据类型
  *
  */
  def format(num: Int, funcName: String, funct: Int => Int): Unit = {
    // %s表示字符串占位符
    val msg = "use %s conver %d to %d"
    println(msg.format(funcName, num, funct(num)))//use max conver -2 to 2
  }

案例

package day01
​
object Functions {
  def main(args: Array[String]): Unit = {
    //val maxF = max _的意思是将max函数赋值给名为maxF的变量，
    //但是在这里max后面添加了一个下划线 _，表示将函数的类型转换为函数值的类型
    val maxFunc = max _
    println(maxFunc(1, 2))
    println(fac(6))
    println(getIndex(Array[Int](1, 2, 3, 4), 3))
​
    println("========================泛化函数转换============================")
​
    format(5,"fac函数",fac)
    format1(-3,abs)
    format2(3,2,"max",max)
  }
​
  /*1、两个值找最大值*/
  def max(a:Int,b:Int):Int = {
    if(a > b) a else b
  }
​
  /*2、取绝对值*/
  def abs(a:Int):Int = {
    // -a中的-表示前缀操作符
    if(a < 0) -a else a
  }
​
  /*3、找目标值在数组中的下标位置*/
  def getIndex(arr:Array[Int],tar:Int):Int={
    // 也是用递归，循环找数组中的值，index是数组下表
    def loop(index:Int):Int={
      // 调用loop时，将index设为0，1、从第一个数查，如果相等返回当前下标
      // 2、如果不相等，index+1作为loop参数，继续调用loop
      // 3、直到数组下标超过数组长度，返回-1
      if (index >= arr.length){
        -1
        // arr(index)表示当前下标的元素值
      }else if (arr(index) == tar){
        index
      }else {
        // 继续查找对比
        loop(index+1)
      }
    }
    loop(0)
  }
​
  /*4、阶乘,使用递归(自己调自己)*/
  def fac(a:Int):Int = {
    // 递归：自己调自己
    // acc表示结果集
    def loop(n:Int,acc:Int):Int={
      if(n ==1) acc
        // 继续调用loop，形成了循环，当n减到1，直接输出结果
        // 先输入（5，1）loop(5,1)==>loop(4,5)==>loop(3,20)==>loop(2,60)==>loop(1,120)
      else loop(n-1,acc*n)
    }
    loop(a,1)
  }
  /*阶乘的另一个方法*/
  def fac1(a:Int):Int={
    if (a ==1 ) 1 else fac1(a-1)*a
  }
​
  def form():Unit={println("=====================格式转换=======================")}
​
  def formatAbs(num: Int): Unit = {
    val msg: String = "source data = %d,abs(num)=%d"
    println(msg.format(num, abs(num)))
  }
  def formatMax(num:Int,num2:Int):Unit={
    val msg: String="source data = %d,%d,max(num)=%d"
    println(msg.format(num,num2,max(num,num2)))
  }
​
  def form1():Unit={println("=====================泛化函数：公共的转换=======================")}
​
  /*
  * 参数列表:1、num:Int表示输入的数字
  * 2、funcName:String一个字符串
  * 3、funct:Int=>Int 定义一个方法，输入int类型，输出int类型，方法名为funct
  *    funct表示自定义的方法名，
  *    Int表示输入的参数类型，
  *    =>表示执行函数，
  *    Int表示执行完函数返回的数据类型
  *
  */
  def format(num: Int, funcName: String, funct: Int => Int): Unit = {
    // %s表示字符串占位符
    val msg = "use %s conver %d to %d"
    println(msg.format(funcName, num, funct(num)))//use max conver -2 to 2
  }
​
  /**/
  def format1(num: Int, fun: Int => Int): Unit = {
    val msg = "use function conver %d to %d"
    println(msg.format(num, fun(num)))
  }
​
  /*两个参数的格式化*/
  def format2(num:Int,num2:Int,functioin:String,fun:(Int,Int)=>Int):Unit={
    val msg="%d,%d使用%s函数得出的结果为：%d"
    println(msg.format(num, num2, functioin,fun(num, num2)))
  }
}

三、高阶函数--多态函数(泛型函数)

把针对单个类型的函数运用到可以针对多个类型，函数名后面加上泛型[A]

1、正常的函数形式

package day01
​
object MultiMode {
  // 正常模式，判断数组中是否含有目标值
  def arrayContain(arr:Array[Int],tar:Int):Boolean={
    def loop(index:Int):Boolean={
      if (index >= arr.length){
        false
      }else if (arr(index) == tar){
        true
      }else{
        loop(index +1)
      }
    }
    // 使用loop函数，从索引0开始
    loop(0)
  }
​
  def main(args: Array[String]): Unit = {
    println(arrayContain(Array[Int](1,2, 3, 4, 5), 5))
  }
}
​

2、多态函数

相当于写一个模板，里面的类型用A表示，A可以是任何参数

案例1：判断一个值是否存在数组中

  /*
  * 两个参数：一个数组和一个函数
  * 1、数组中元素类型在调用时可以定义
  * 2、函数参数func:(A=>Boolean)：表示这个形参func函数是输入一个A类型的数，返回Boolean类型的值
  * 但是具体怎么执行，等调用这个函数时，用具体的执行方式来替换这个形参
  * */
  def arrayMulti[A](arr:Array[A],func:A=>Boolean):Boolean={
    def loop(index:Int):Boolean={
      if (index >= arr.length){
        false
        // 表示调用这个形参返回的Boolean值，具体是什么执行方法，在调用时写出来，但不管怎么写，arr(index)就是写的函数形参的参数
      }else if (func(arr(index))){
        true
      }else{
        loop(index +1)
      }
    }
    // 使用loop函数，从索引0开始
    loop(0)
  }
​
  def main(args: Array[String]): Unit = {
    /*第二个参数应该是一个函数
    def func(x:Int):Boolean={
    if (x == 5) true
    else false
    }
    这个func咱们简写了，func在loop函数被多次循环调用时，参数x就是arr(index)
     */
    // (x: Int) => x == 5
    println(arrayMulti(Array[Int](1, 2, 3, 4), (x: Int) => x == 5))
    println(arrayMulti(Array[String]("a", "b", "c"), (x: String) => x.equals("b")))
  }

案例2：判断一个数组是否是升序（或降序）排列

package day01
​
object MultiMode {
​
  /*多态函数
  * 判断这个数组是否是升序(后降序)排列
  * */
  def multi[A](ar:Array[A],func:(A,A)=>Boolean):Boolean={
    /*
    逻辑：从索引0开始，0>= 4,false,不返回true，继续向下1<2,正确，但是前面加了！，所以还不返回，继续执行索引1
    直到 6<5，错误，取反后为true，则返回false，结果就是false
     */
    def loop(index:Int):Boolean={
        //表示查到末尾还没返回false，则整个数组就是正确的排序，中途有错误的，直接就返回false了，执行不到这里了
      if (index >= ar.length -1) true
        // 顺序正确，就取反让其不返回false，继续查找，直到顺序不正确，取反if条件就成功执行，返回了false
      else if (!func(ar(index),ar(index + 1))) false
        // 继续查找
      else loop(index + 1)
    }
    loop(0)
  }
​
  def main(args: Array[String]): Unit = {
    println(multi[Int](Array[Int](1, 2, 3, 6, 5), (x: Int, y: Int) => x <= y))
  }
}

返回值是函数的案例

  def currying(x:Int,func:(Int,Int)=>Int):Int=>Int={
    // 返回值是个函数Int=>Int,所以要传值一个Int类型的值，结果为Int类型(刚好func参数就是返回的Int值，所以借用func函数)
    // (y:Int) => func(x,y)这个就是一个匿名函数，符合返回一个函数的要求
    // 传一个Int值
    (y:Int) => func(x,y)
  }
​
  /*
  * 两个参数：1、一个A类型的数值
  * 2、一个类型A和类型B生成一个类型C的函数
  * 返回值：一个类型B生成一个类型C的函数
  * 方法体：一个匿名函数：传一个类型B的值生成(由上面函数形参func生成的类型C数据)类型C数据
  * */
  def currying1[A,B,C](a:A,func:(A,B)=>C):B=>C={
    (b:B)=>func(a,b)
  }
​
​
  def main(args: Array[String]): Unit = {
    // currying(2, (x: Int, y: Int) => x + y) 返回的这个表达式是函数
    val int_int = currying(2, (x: Int, y: Int) => x + y)
    println(int_int(4))//6
​
    val cur = currying1[Int,Int,String](5,(a:Int,b:Int)=> s"${a}${b}")
    println(cur(20))//520
  }

四、柯里化函数(Currying)

将参数分开，每个参数都形成了一个函数

作用：协助编译器进行类型推断

  /*正常函数*/
  def noCurry(x:Int,y:Int):Int={
    x + y
  }
​
  /*柯里化函数*/
  def curry(x:Int)(y:Int):Int={
    x + y
  }
​
  def main(args: Array[String]): Unit = {
    println(noCurry(2, 3))
    println(curry(1)(3))
  }

高阶案例

  /*
  * 这个函数就是柯里化函数的证明过程
  * 返回值就相当于：A=>(B=>C)，因为函数是偏右法则，所以()省略了
  * A赋值1，B赋值2，流程就是：f(1)结果是一个函数(类型A生成)
  * */
  def curri[A,B,C](f:(A,B)=>C):A=> B=>C={
        // 相当于(a:A)=>{(b:B)=> f(a,b)}
    (a:A)=> (b:B)=>f(a,b)
  }
​
  /*
  * 这个函数就是柯里化函数的反证明过程
  * */
  def recurr[A,B,C](f:A=>B=>C):(A,B)=>C={
    (a:A,b:B)=> f(a)(b)
  }
​
​
  def main(args: Array[String]): Unit = {
    val func = curri[Int,Int,Int]((x:Int,y:Int)=> x+y)
    println(func)//是一个函数
    println(func(3))//也是一个函数
    println(func(3)(2))//5
  }

案例

   def arrayMulti[A](arr: Array[A])(func: A => Boolean): Boolean = {
    def loop(index: Int): Boolean = {
      if (index >= arr.length) {
        false
        // 表示调用这个形参返回的Boolean值，具体是什么执行方法，在调用时写出来，但不管怎么写，arr(index)就是写的函数形参的参数
      } else if (func(arr(index))) {
        true
      } else {
        loop(index + 1)
      }
    }
    // 使用loop函数，从索引0开始
    loop(0)
  }
  
  def main(args: Array[String]): Unit = {
​
    // 第二个参数本来应该是(x:Int=> x == 5),
    // 因为是柯里化函数，第二个参数的入参类型可以省略了
    println(arrayMulti(Array(2, 3, 4, 5, 7))(x => x == 5))
  }

余淮~
关注
scala集合中的函数详解大全(一)
Fresh_man888的博客
11-04 1389
0 目录 1.foreach函数 2.map函数 3.filter和filterNot(过滤函数) 4.collect函数 5.min和max 6.minBy和maxBy 7. sum函数 8. find 函数 9. flatten 函数 10flatMap函数 11mapValues 函数 12sorted函数 13sortBy和sortWith 函数 14.partition和span 函数 15grouped 函数和groupBy函数 1.for...
Scala集合的常用方法：sum/max/min/product
学亮编程手记
04-16 2632
五-2, Scala集合常用函数全总结
菜菜的大数据开发の路
02-21 1431
五-2, 集合常用函数 在学习本文之前, 必须掌握以下知识点 函数的最简化原则 元组的概念和使用方法 函数柯里化 隐式参数(可选) 1. 集合的基础方法/函数 用法 解释 Array, List, Set, Map使用区别 xx.length 或 xx.size 获取集合长度(大小) (Array, List均有length, size方法, 而Set, Map只有 size方法) xx.foreach(println) 循环遍历 均可使用 xx.iterator 迭代器
Scala函数初体验
残缺的孤独
12-04 690
Scala 函数初体验
Scala函数式编程
04-17
《Scala函数式编程》是针对希望学习FP并将它应用于日常编码中的程序员而写的，内容包括：函数式编程的概念；函数式编程相关的各种“为什么”和“怎么做”；如何编写多核程序；练习和检测。 从OOP到FP，思路的转化 ...
Scala函数式编程.pdf
05-18
函数式编程（FP）是一种...《Scala函数式编程》是针对希望学习FP并将它应用于日常编码中的程序员而写的，内容包括：函数式编程的概念；函数式编程相关的各种“为什么”和“怎么做”；如何编写多核程序；练习和检测。
Scala中的函数至简原则
liusuoyin的博客
09-23 743
Scala中的函数至简原则  因为Scala是函数式编程，函数可以在Scala中以参数、返回值和变量等形式和位置使用。所以函数至简原则显得至关重要，总的来说，函数至简原则就是能省则省，有人说“你那不废话吗”，重点是怎么简？在哪里可以简？下面一一讲明： （1）return可以省略，Scala会使用函数体的最后一行代码作为返回值 （2）如果函数体只有一行代码，可以省略花括号 （3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略） （4）如果有return，则不能省略返回值类型，必须指定 （5）
大数据系列第一课：scala基础
lhui798的专栏
01-03 559
内容： 1 Scala的重大价值 2 Scala基础语法入门实战 3 Scala函数入门实战 4 Scala中Array、Map、Tuple实战 5 综合案例及Spark源码解析 一、scala价值 Scala可伸缩的语言的英语翻译是：Scalable Language。它是一门多范式的编程语言，一种类似java的编程语言，集成面向对象编程和函数式编程的各种特性并完美结合，熟练掌握s
scala中的函数和方法
liyang7916的博客
04-09 2200
一：scala中的函数 Scala中，函数上升和变量同等的位置，或者说函数也是一种变量； Scala中的函数可以作为实参传递给另一个函数； 函数可以作为返回值； 函数可以赋值给变量(这个变量需符合函数的类型的变量)； 函数可以存储在数据结构之中。 函数如同普通变量一样，也具有类型； 函数的定义可以有很多种，因此需要掌握最基本的定义方法： 1，函数的基本定义 val f1 = (a: Int, b: Int) => a + b val f2 = ((a: Int, b: Int.
scala 方法大全（你必须掌握的百种方法！！！）
WCL0520的博客
09-10 1165
–scala函数整合 – ++ 合并集合，并返回一个新的数组 var k = Array(1,2,3,"a") var e = Array("a","b","c") k++e 结果：Array(1,2,3,a,a,b,c)(新数组) – ++：并数组，结果由冒号右边类型决定 var d = List(1,2,3,4) var f = Array("a","b","c") d++:f 结果：Array(1, 2, 3, 4, a, b, c) f++:d 结果：List(a, b, c, 1, 2, 3,
Scala函数、条件表达式、循环语句
吃果冻不吐果冻皮
11-02 3657
定义有返回值函数def max(x:Int,y:Int):Int = { if(x>y) x else y }只有一行的情况，可以省略括号。def max(x:Int,y:Int):Int =if(x>y) x else ydef max(x:Int,y:Int) = if(x>y) x else y定义无返回值函数def greeting() = println("hello,wo
Scala函数--中级函数式--Scala中参数个数最大值为22个
C_Xiang_Falcon的博客
10-18 1129
Scala函数--中级函数式--Scala中参数个数最大值为22个 def main(args: Array[String]): Unit = { 至简原则 中级版函数式编程 原版 1.如果函数逻辑中需要返回结果,那么return关键字可以省略 可以将函数体中最后一行代码作为函数的返回结果 2.如果可以通过返回值推断出返回值类型,那么返回值类型可以省略 3.如果函数的主体内容只有一行代...
Scala定义函数的5种方式
学亮编程手记
03-26 6632
大数据spark的源码是用scala来开发的，因此学习scala来开发spark会更加便捷。 Scala中第一函数的接种方式如下： 规范化写法，scala函数的返回值是最后一行代码 Unit是scala语言中数据类型的一种，表示无值，用作不返回任何结果的方法； 不写明返回值的类型，程序会自行判断，最后一行代码的执行结果为返回值； 省略返回值类型和等于号，返回的是();
scala常用函数大全
qq_41704237的博客
08-02 1730
一、添加、更新元素函数 ++ 两个集合相加，返回一个左边集合类型的新集合 val a = Array(1, 2) val b = Array(3, 4) val c = a ++ b println(c.mkString(",")) // 1,2,3,4 ++：两个集合相加，返回一个右边集合类型的新集合 val a = List(1, 2) val b = scala.collection.mutable.LinkedList(3, 4) val c = a ++:
scala编程学习笔记（一）变量定义函数定义
热门推荐
luyee2010的专栏
04-16 1万+
变量定义： val:类似java中final类型的变量 1，基本格式：val 变量名：变量类型 = 值2，其中有时变量类型可以省略，可以自动识别3，变量不能赋值，修改 var :等同于java中的非final型变量 val msg: java.lang.String = "Hello World String" println("msg: " +msg) var msgVar: ja
Scala中的方法&函数的定义
wolfcode_cn的博客
10-29 4090
作者：林伟兵，叩丁狼高级讲师。本文为原创文章，转载请注明出处。   4. 方法&amp;函数的定义 在scala中，函数是一等公民，但是一般在开发中，函数和方法是可以相互代替的。 4.1 方法的定义 一个完整方法的定义如下 scala&gt; def add(a:Int, b:Int):Int = { | return a+b | } add: (a: I...
Scala 中 10 个超赞的集合操作函数
程序猿开发日志【学习永无止境】
01-06 6663
当我处理 Scala 集合时，我会进行两类操作：转换操作和聚合操作。第一种操作类型将集合转换为另一个集合，第二种操作类型返回某些类型的值。 本文我将集中介绍几个日常工作必备的 Scala 集合函数，如转换函数和聚合函数。文章最后，我会展示如何结合这些函数以解决具体问题。 #1 最大值和最小值 我们先从动作函数开始。 在序列中查找最大或最小值是一个极常见的需求，较常用
Scala函数式编程模式实战
1. 了解函数式编程的基本理念，以及Scala函数式编程特性如何提升代码的健壮性、安全性和简洁性。 2. 应用函数式编程模式解决实际编程挑战，减少模板代码，以更简洁优雅的方式表达设计模式。 3. 减少系统复杂性，通过...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值