精华内容
下载资源
问答
  • Scala高阶函数

    2021-08-07 21:09:20
    一、scala自带高阶函数 概述:可以接收一个函数的函数就是高阶函数,又称为算子 1。map: 将集合中的每一个元素通过指定功能(函数)映射(转换)成新的结果集 val list1 = List(1,2,3) val list2 = list1.map(v=>v*2...

    一、scala自带高阶函数

    概述:可以接收一个函数的函数就是高阶函数,又称为算子

    1。map:

    将集合中的每一个元素通过指定功能(函数)映射(转换)成新的结果集

    val list1 = List(1,2,3)
    val list2 = list1.map(v=>v*2)
    println(list2)			//List(2, 4, 6)
    

    2.flatten

    介绍:flat即压扁,压平,扁平化。效果就是将集合中的每个元素的子元素映射到某个函数并返回新的集合

    var list = List(List(1,2,3),List(3,4,5))
    val list2 = list.flatten
    println(list2)          // 输出结果:List(1, 2, 3, 3, 4, 5)
    
    val list3 = List(Array("zhangsan","lisi"),Array("lisi","wangwu"))
    println(list3.flatten)
    

    3.flatMap

    介绍:先执行map,在执行flatten

    var list = List("zhangsan lisi","lisi wangwu","wangwu wangwu")
    val list2 = list.flatMap(v=>v.split(" "))
    println(list2)    //输出:List(zhangsan, lisi, lisi, wangwu, wangwu, wangwu)
    
    

    4.filter (过滤器)

    介绍:将符合要求的数据,通过指定函数的筛选放置到新的集合中
    需求:将集合中首字母为‘A’的筛选到新的集合

    var list = List("Alice","Tom","Jack","Abc")
    val list2 = list.filter(v => {
       v.startsWith("A")
    })
    println(list2)			//输出结果:List(Alice, Abc)
    

    5.reduce

    介绍:对集合中的元素进行归约操作
    需求:计算List集合中所有元素的和

    var list = List(1,2,6,8)
    val i: Int = list.reduce((v1,v2)=>v1+v2)
    println(i)
    

    6.fold

    介绍:fold函数将上一步返回的值作为函数的第一个参数继续传递参与运算
    需求: 计算List集合中所有元素的和

    var list = List(1,2,6,8)
    val i: Int = list.fold(5)((v1, v2) => {
          v1 + v2
    })
    println(i)
    
    上述代码等同于
    list(5,1,2,6,8).reduce((v1, v2) => {
          v1 + v2
    })
    

    7.sorted

    介绍:对集合中的元素进行排序

    var list = List(1,13,4,34)
    println(list.sorted)            	//输出结果 List(1, 4, 13, 34)
    println(list.sorted.reverse)		//输出结果 List(34, 13, 4, 1)
    

    8.sortBy

    介绍:对集合中元组的某个元素进行排序

    //List集合中存储一个学生的信息,分别是姓名和语文成绩,请按照语文成绩排序
    var list = List(("张三",100),("李四",84),("王五",95),("赵六",30))
    println(list.sortBy(t => t._2))			//List((赵六,30), (李四,84), (王五,95), (张三,100))
    println(list.sortBy(t => t._2).reverse) //List((张三,100), (王五,95), (李四,84), (赵六,30)
    
    
    //List集合中存储一个学生的信息,分别是姓名和语文成绩、数学成绩
    //请按照语文成绩先排序,语文成绩相等者,按照数学成绩排序
    var list2 = List(("张三",100,58),("李四",84,96),("王五",84,75),("赵六",30,61))
    println(list2.sortBy(v => (v._2, v._3))(Ordering.Tuple2(Ordering.Int,Ordering.Int.reverse)))
    
    //输出结果:List((赵六,30,61), (李四,84,96), (王五,84,75), (张三,100,58))
    

    9.groupBy

    介绍:根据集合中包含元组进行分组

    var list = List(("张三",100),("张三",96),("李四",84),("李四",30))
    //.groupBy(v=>v._1) 作用:根据遍历集合获取元组的第一个元素进行分组
    val map: Map[String, List[(String, Int)]] = list.groupBy(v=>v._1)
    println(map)
    

    10.foreach

    介绍:遍历集合中的元素

     var list = List("张三","李四","王五")list.foreach(v=>{
        println(v)
        })
    

    11.关于高阶函数的形参(匿名函数)的写法

    val list = List(1,2,3)
    1.正常的写法
      list.map( (v:Int) => v*2 )
      
    2.如果可以正常推断出匿名函数的形参类型,则:Int可以省略
      list.map( (v) => v*2 )
      
    3.如果匿名函数的形参个数只有1个,则()小括号可以省略
      list.map( v => v*2 )
      
      list.reduce( (v1,v2) => v1+v2 )    //此处(v1,v2)对应的小括号不能省略
    
    4.如果匿名函数的形参(每一个),在匿名函数的代码体中只出现一次,则可以将形参列表和=> 省略,并且在函数体中使用_代表形参
      list.map( v => v*2  )   对应简写  list.map( _*2  )
      list.map( v => v*v )    不能使用_简写
      
      list.reduce( (v1,v2) => v1+v2 )  对应简写   list.reduce( _+_ )
    

    二、高级函数

    1.闭包

    闭包是一个函数,返回值依赖于声明在函数外部的一个或多个变量。
    闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数

    介绍: 闭包就是一个函数和与其相关的引用环境组合的一个整体

    def minus(x:Int)= (y:Int)=> x-y
    
    val f1 = minus(20)   //此处的f1就是闭包
    f1(1)  //输出19
    f1(2)  //输出18
    
    详解:
    ①  (y:Int)=> x-y 
         代表minus这个函数的返回值是一个匿名函数,那么将来这个匿名函数执行时就需要引入外部环境变量x
         这就形成了闭包
    ②  当多次调用f(可以理解多次调用闭包) 发现使用的是同一个x,所以x不变
    ③  在使用闭包时,主要搞清楚返回函数引用了函数外的哪些变量,因为他们会组合成一个整体
    

    2.函数柯里化

    介绍:函数编程中,接受多个参数的函数都可以转化为接收单个参数的函数,这个转化过程就叫柯里化
    柯里化就是证明了函数只需要一个参数而已,不用设立柯里化存在的意义这样的命题。柯里化就是以函数为主体这种思想发展的必然产生结果
    需求:编写一个函数,接收两个整数,可以返回两个数的乘积

    //常规方式完成
    def test1(v1:Int,v2:Int)={
        v1+v2
    }
    test1(10, 20)
    
    //闭包
    def test2(x:Int)= (y:Int)=>x+y
    test2(10)(20)
    
    //柯里化
    def test3(x:Int)(y:Int)={
        x+y
    }
    test3(10)(20)
    
    展开全文
  • 1、定义一个高阶函数,按照指定的规则对集合里面的每个元素进行操作 比如: Array(“spark”,“hello”,“java”,“hadoop”) 规则: 对集合中每个元素进行操作,得到集合每个元素的长度 object Test01 { def main...

    1、定义一个高阶函数,按照指定的规则对集合里面的每个元素进行操作
    比如: Array(“spark”,“hello”,“java”,“hadoop”)
    规则: 对集合中每个元素进行操作,得到集合每个元素的长度

    object Test01 {
      def main(args: Array[String]): Unit = {
        val list = Array("spark", "hello", "java", "hadoop")
    
        //完整写法
        val fun = (s: String) => {
          s.length
        }
        println(doSome(list, fun))
    
        //匿名写法
        println(doSome(list, (s: String) => {
          s.length
        }))
        //省略类型,大括号
        println(doSome(list,(s)=>s.length))
        //省略小括号
        println(doSome(list,s=>s.length))
        //用_
        println(doSome(list,_.length))
    
      }
    
      def doSome(list: Array[String], fun: (String) => Int) = {
        val res = for (elem <- list) yield {
          fun(elem)
        }
        res.toList
      }
    }
    

    2、定义一个高阶函数,对数据中的元素按照指定的规则进行过滤
    比如: Array(1,4,7,9,10,6,8)
    规则: 只保留偶数数据

    object Test02 {
      def main(args: Array[String]): Unit = {
        val list = Array(1,4,7,9,10,6,8)
        println(filter(list,(_%2==0)))
      }
    
      def filter(list: Array[Int],fun:(Int)=>Boolean) = {
      	//用fun做守卫,过滤
        val res = for (elem <- list if (fun(elem))) yield {
          elem
        }
        res.toList
      }
    }
    

    3、对数据中的元素按照指定规则进行分组
    比如:Array(“zhangsan shenzhen man”,“lisi beijing woman”,“zhaoliu beijing man”)
    规则: 按照地址进行分组

    object Test03 {
      def main(args: Array[String]): Unit = {
        val list = Array("zhangsan shenzhen man","lisi beijing woman","zhaoliu beijing man")
        println(group(list,_.split(" ")(2)))
      }
    
      def group(list:Array[String],fun:(String)=>String) = {
        val map = new util.HashMap[String,util.ArrayList[String]]()
        for (elem <- list) {
          val key = fun(elem)
          if(map.containsKey(key)){
            map.get(key).add(elem)
          }else{
            val value = new util.ArrayList[String]()
            value.add(elem)
            map.put(key,value)
          }
        }
        map
      }
    }
    

    4、根据指定的规则获取数组中最大元素
    比如:val list = Array(“zhangsan 30 3500”,“lisi 25 1800”,“zhaoliu 29 4500”,“qianqi 30 4500”)
    规则: 获取工资高的人的信息,可能有多个

    object Test04 {
      def main(args: Array[String]): Unit = {
        val list = Array("zhangsan 30 3500","lisi 25 1800","zhaoliu 29 4500","qianqi 30 4500")
        println(getMax(list,_.split(" ")(2 ).toInt))
      }
    
      def getMax(list:Array[String],fun:(String)=>Int) = {
        var max = fun(list(0))
        val res = new util.ArrayList[String]()
        for (elem <- list) {
          val cru = fun(elem)
          if (max<cru) max = cru
        }
        //找出所有信息
        for (elem <- list) {
          val cru = fun(elem)
          if (max==cru) res.add(elem)
        }
        res
      }
    
    }
    

    5、根据指定规则对数组所有元素聚合
    比如:Array(10,4,6,10,2)
    规则: 求和/求乘积

    object Test05 {
      def main(args: Array[String]): Unit = {
        val list = Array(10,4,6,10,2)
        println(poly(list,_+_))
      }
    
      def poly(list:Array[Int],fun:(Int,Int)=>Int) = {
        var res = list(0)
        for (i<-1 until list.size) res = fun(res,list(i))
        res
      }
    }
    

    6、编写函数values(fun: (Int) => Int, low: Int, high: Int),该函数输出一个集合,对应给定区间内给定函数的输入和输出。
    比如:values(x => x * x, -5, 5)应该产出一个对偶的集合(-5, 25), (-4, 16), (-3, 9), …, (5, 25)

    object Test06 {
      def main(args: Array[String]): Unit = {
        println(values(x => x * x, -5, 5))
      }
    
      def values(fun: (Int) => Int, low: Int, high: Int)={
        val list = new util.ArrayList[String]()
        for (i<-low to high){
          val res = fun(i.abs)
          list.add(s"(${i}, ${res})")
        }
        list
      }
    }
    

    7、如何用得到数组中的最大元素
    比如:var array = Array(1,2,3,4,5,6,7,88,100,123,14444)

    object Test07 {
    
      def main(args: Array[String]): Unit = {
        var array = Array(1,2,3,4,5,6,7,88,100,123,14444)
        val res = getMax(array,_-_)
        println(res)
      }
    
      def getMax(arr:Array[Int],fun:(Int,Int)=>Int) = {
        var max = arr(0)
        for (i<- 1 until  arr.length){
          val res = fun(max,arr(i))
          if (res < 0) max = arr(i)
        }
        max
      }
    
    }
    

    8、实现阶乘函数,不得使用循环或递归

    object Test08 {
      def main(args: Array[String]): Unit = {
        val res = factorial(4,_*_)
        println(res)
      }
    
      def factorial(n:Int,fun:(Int,Int)=>Int) = {
        var res = 1
        for (i<- 2 to n) res=fun(res,i)
        res
      }
    }
    

    9、编写函数largest(fun: (Int) => Int, inputs: Seq[Int]),输出在给定输入序列中给定函数的最大值。举例来说,largest(x => 10 * x - x * x, 1 to 10)应该返回25。不得使用循环或递归

    object Test09 {
    
      def main(args: Array[String]): Unit = {
        val res = largest(x => 10 * x - x * x, 1 to 10)
        println(res)
      }
    
      def largest(fun: (Int) => Int, inputs: Seq[Int]) = {
        var max = fun(inputs(0))
        for (elem <- inputs) {
          val cru = fun(elem)
          if (cru>max) max = cru
        }
        max
      }
    
    }
    

    10、修改前一个函数,返回最大的输出对应的输入。举例来说,largestAt(fun: (Int) => Int, inputs: Seq[Int])应该返回5。不得使用循环或递归

    object Test10 {
    
      def main(args: Array[String]): Unit = {
        val res = largest(x => 10 * x - x * x, 1 to 10)
        println(res)
      }
    
      def largest(fun: (Int) => Int, inputs: Seq[Int]) = {
        var max = fun(0)
        var res = 0
        for (i <-1 until  inputs.length) {
          val cru = fun(i)
          if (cru>max) {
            max = cru
            res = i
          }
        }
        res
      }
    
    }
    
    展开全文
  • Scala 高阶函数自己总结 基础文档 之前自己总结的笔记,重点看 《Scala 中方法和函数底层Java 实现》 代码讲解 // HOFunc.scala package com.abc.scala object HOFunc { // 一、高阶函数说明 /* 1. Scala 命名...

    Scala 高阶函数自己总结

    基础文档

    之前自己总结的笔记,重点看 《Scala 中方法和函数底层Java 实现》

    代码讲解

    // HOFunc.scala
    package com.abc.scala
    
    object HOFunc {
      // 一、高阶函数说明
      /*
      1. Scala 命名函数用def 定义,其底层实现跟Java 中定义方法一样,为了跟Scala 匿名函数区分也称其为"方法"
      2. Scala 匿名函数通过赋值给变量,用变量名进行调用,其底层是一个对象,函数体定义写在该对象的apply 方法里
      3. Scala 将输入或输出(即参数或返回值)的类型为函数的函数称为高阶函数(Higher Order Function)
      4. Java 中没有函数指针的概念,所以不能直接将一个方法作为参数传给另一个方法,但对象可以作为参数传给方法
      所以,Scala 中高阶函数的参数只能是底层为对象的匿名函数,即使传入了方法,Scala 也会自动将其转换为匿名函数
      */
    
    
      // 二、高阶函数(参数为函数)
      // def 高阶函数名(参数名: [参数类型 => 返回值类型 [, 其他参数类型]]): 高阶函数返回值 = { 高阶函数体定义 }
      def hof_par2(op: String => String, arg1: String): Unit = {
        println(op(arg1))
        // 参数1 函数op (输入类型为String,输出类型为String)
        // 参数2 字符串arg1 作为输入传给op 执行
        // 高阶函数hof_par2 没有返回值即Unit
      }
    
      // 匿名函数只须写参数名和类型,不用写返回值类型,Scala 会根据 => 右边最后一行代码结果自动进行类型推断
      val op1 = (name: String) => { "op1: hello " + name }
    
      // 将函数传给高阶函数
      hof_par2(op1, "ABC")  // hello ABC
    
      // 函数类型的参数简化(占位符 _ 语法糖)
      // 传统方式将匿名函数传给高阶函数,有点繁琐,
      hof_par2((name1:String) => { "Anonymous: hello " + name1}, "ABC")
      /*
      以下这条语句虽不符合Scala 语法,编译不通过,但很好地诠释了占位符 _ 的位置
      hof_par2( (_) => { "Predigesting: hello " + _ }, "ABC")
      由于高阶函数hof_par2 定义了输入函数的参数类型,所以Scala 可以推断出(_) 代表什么
      又因为在 => 右边只出现了一个 _ 与 (_) 中的数量对应,所以多余的代码须将它们精简掉
      即连同 => 及其左边的代码都去掉,只保留有效代码{ "Predigesting: hello " + _  }
      根据Scala 的风格,只有一行语句时,括号() 或花括号{} 都是可以省略的,最终简化结果如下
      */
      hof_par2( "Predigesting: hello " + _ , "ABC")
    
      // 注意!高阶函数中如果传入的函数没有参数就相当于用{} 包起来的一个代码块,返回值是最后一行代码的结果
      def hof_par0(op: => Unit): Unit = { op }  // 定义高阶函数
      val op0 = { println("No P and R") }       // 定义无参函数(代码块)
      hof_par0(op0)                             // 调用高阶函数
    
    
      // 三、高阶函数(返回值为函数)
      def hof_ret(prefix: String) = {
        (name: String) => { println(prefix + name) }  // 返回一个匿名函数
      }
      // 获取函数
      val hr1 = hof_ret("VIP_")
      // 调用该函数
      hr1("BBB")
    
    
      // 四、创建程序执行入口
      def main(args: Array[String]): Unit = {
        // 创建main 函数让以上代码在HOFunc$ 对象的构建函数中运行,详见Scala object 的底层分析笔记
      }
    
    }
    

    编译运行

    # 先将以上代码写入文件HOFunc.scala 然后执行
    scalac HOFunc.scala && scala com.abc.scala.HOFunc
    
    

    参考文档

    高阶函数
    HIGHER-ORDER FUNCTIONS

    展开全文
  • [Scala高阶函数示例]

    万次阅读 2018-05-13 09:23:18
    在Scala中,可以直接将某个函数作为参数传入其他的.../** * Scala高阶函数示例 */objectHighOrderFunction { /* * greeting就是高阶函数 * name:String类型的一个正常参数 * func:函数类型的一个参数,定义...

    在Scala中,可以直接将某个函数作为参数传入其他的函数。带函数参数的函数由于是一个接受函数参数的函数,故被称为高阶函数(High-Order function)。

    /**

     * Scala高阶函数示例

     */

    objectHighOrderFunction {

      /*

        * greeting就是高阶函数

        * name:String类型的一个正常参数

        * func:函数类型的一个参数,定义一个接受String类型的,返回值类型为Unit的函数这样的一个参数函数

        * */

      defgreeting(name: String, func: (String) => Unit) = {

        func(name)

      }

      defsayHiFunc(name: String) = {

        println(s"Hi,${name}")

      }

      defmain(args: Array[String]): Unit = {

        defsayHelloFunc(name: String) = {

          println(s"Hello,${name}")

        }

        //把函数赋值给变量

        valsayHello = sayHelloFunc _

        greeting("xiaoming", sayHello)

        //=======================================================

        greeting("zhangsan", sayHiFunc _)

        //由于greeting函数定义的时候要求第二个参数必须是函数类型,所以这里可以直接写函数名称,

        //表示其实就是传递了一个函数,可以不加下划线

        greeting("zhangsan", sayHiFunc)

        //=======================================================

        //匿名函数一般和高阶函数是一起使用的,匿名函数作为高阶函数的输入参数

        greeting("xiaoming", (abc: String) => {

          println(s"nihao,${abc}")

        })

        //高阶函数的简化

        //可以将输入参数的数据类型省略,原因:scala的编译器会自动的根据上下文的内容就行推断

        //自动推断数据类型

        greeting("zhangsan", (abc) => { println(s"nihao,${abc}") })

        //如果只有一个输入参数,可以考虑省略小括号

        greeting("zhangsan", abc => { println(s"nihao,${abc}") })

        //如果左侧的所有的输入参数在右侧的函数体中有且仅有一次而且使用的顺序和输入参数的列表中的顺序是一致的

        //可以考虑省略输入参数,并使用_代替,实际开发中不建议使用,阅读起来很费劲

        greeting("zhangsan", println(_))    //===============================================================================================

        defopera(a: Int, b: Int, func: (Int, Int)=> Int) = {

          println(s"result=${func(a, b)}")

        }

        valvalue1: Int = 9;

        valvalue2: Int = 2;

        println(s"求和:${value1} + ${value2}")

        opera(value1, value2, (x: Int, y: Int) => x+y)

        opera(value1, value2, (x, y) => x+y)

        //第一个下划线表示第一输入参数,第二个下划线表示第二个输入参数

        opera(value1, value2, _ + _)

        println(s"差值${value1} - ${value2}")

        opera(value1, value2, (x: Int, y: Int) => x-y)

        opera(value1, value2, (x, y) => x-y)

        //第一个下划线表示第一输入参数,第二个下划线表示第二个输入参数

        opera(value1, value2, _ - _)

        println(s"乘积${value1} * ${value2}")

        opera(value1, value2, (x: Int, y: Int) => x*y)

        opera(value1, value2, (x, y) => x*y)

        //第一个下划线表示第一输入参数,第二个下划线表示第二个输入参数

        opera(value1, value2, _ * _)

        println(s"取模:${value1} / ${value2}")

        opera(value1, value2, (x: Int, y: Int) => x/y)

        opera(value1, value2, (x, y) => x/y)

        //第一个下划线表示第一输入参数,第二个下划线表示第二个输入参数

        opera(value1, value2, _ / _)

      }

    }

     

    运行结果:

    Hello,xiaoming

    Hi,zhangsan

    Hi,zhangsan

    nihao,xiaoming

    nihao,zhangsan

    nihao,zhangsan

    zhangsan

    求和:9 + 2

    result=11

    result=11

    result=11

    求差:9 - 2

    result=7

    result=7

    result=7

    求积:9 * 2

    result=18

    result=18

    result=18

    求模:9 / 2

    result=4

    result=4

    result=4


    展开全文
  • 18 高阶函数 在数据和计算中,高阶函数是至少满足下列一个条件的函数: ​ 1)接受一个或多个函数作为输入 ​ 2)输出一个函数 输出一个函数 // 输出Int类型 scala> def add(a:Int, b:Int) = a + b add: (a: Int,...
  • 菜鸟理解的Scala高阶函数

    万次阅读 2019-08-07 16:32:12
    Scala中的高阶函数,主要包含三种: 函数的参数是函数。 函数的返回值是函数。 函数的参数和返回值都是函数。 下面通过三种不同的函数形式,来实现阶乘。 1、函数的参数是函数 已知函数1实现阶乘计算,在函数2中...
  • Scala高阶函数介绍

    2019-11-13 17:09:12
    Scala混合了面向对象和函数式的特性。在函数式编程语言中,函数是"头等公民",可以像其他任何数据类型一样被传递和操作。在函数式编程语言中,只需要将具体实现包在函数中作为参数传入即可。 作为值的函数 ...
  • 1、定义一个高阶函数,按照指定的规则对集合里面的每个元素进行操作 比如: val arr = ArrayString 对集合中每个元素进行操作,得到集合每个元素的长度 val result = ArrayInt 2、定义一个高阶函数,按照指定的规则对...
  • scala 高阶函数

    2020-07-20 16:48:04
    通俗点讲,高阶函数就是一个函数可以接收一个函数 接收一个有参数的函数 package com.xcu.chapter11.map object demo01_map { def main(args: Array[String]): Unit = { val res = test(sum, 3) println(res...
  • 高阶函数1、作为值的函数2、匿名函数3、柯里化4、闭包 Scala混合了面向对象和函数式的特性,我们通常将可以作为参数传递到方法中的表达式叫做函数。在函数式编程语言中,函数是“头等公民”,高阶函数包含:作为值...
  • Scala高阶函数详解

    千次阅读 2018-03-16 13:09:54
    概述高阶函数主要有两种:一种是将一个函数当做另外一个函数的参数(即函数参数);另外一种是返回值是函数的函数。用函数作为形参或返回值的函数,称为高阶函数。(1)使用函数作为参数//函数参数,即传入另一个...
  • scala高阶函数练习

    千次阅读 2020-07-25 09:01:54
    Int,low:Int,hight:Int)该函数输出一个集合,对应给定区间内给定的给定函数的输入和输出比如values(x=>x*x,-5,5)应该产出一个对偶集合(-5,25)(-4,16)(-3,9)...(5,25)2.如何用reduceLeft得到数组中的...
  • Scala>scala高阶函数

    2020-04-06 23:14:37
    文章目录高阶函数作为值的函数匿名函数柯里化闭包 高阶函数 概念 Scala混合了面向对象和函数式的特性,我们通常将可以作为参数传递到方法中的表达式叫做函数。在函数式编程语言中,函数是“头等公民”,高阶函数包含...
  • scala高阶函数练习题

    2019-01-30 16:24:13
    * 编写函数values(fun:(Int)=&gt;Int,low:Int,hight:Int) * * 该函数输出一个集合,对应给定区间内给定的给定函数的输入和输出,R比如values(x=&gt;x*x,-5,5) * 应该产出一个对偶集合(-5,25),(-4,...
  • scala高阶函数

    2016-09-13 19:08:49
    1.scala中,接受函数参数,或者是返回函数的函数,被称为高阶函数。 1.1接受函数作为参数的示例:object test{ def main(args: Array[String]){ def valueAtOneQuarter(f:(Double)=>Double)=f(0.25) //该函数...
  • Scala高阶函数练习三

    2021-04-02 10:00:51
    Int) = { def f1(b: String) = { def f2(c: Char): Boolean = { if (a == 0 && b == "" && c == '0') { false } else { true } } f2 _ } f1 _ } 例三:匿名函数简写 def main(args: ...
  • Scala高阶函数说明和使用 函数在Scala中是“头等公民”,它的使用方法和任何其他变量是一样的。所谓高阶函数(Higher-Order Function)就是操作其他函数的函数。Scala 中允许使用高阶函数, 高阶函数可以使用其他函数...
  • Scala高阶函数学习

    2018-02-08 11:51:05
    Scala函数式编程使得算法的设计可以更高效更精简,因为函数式是依赖人们的思考 方式构建的。 Spark中的计算几乎所有都是用函数式编写的,而且我们在处理数据一般都是针对集合的,集合的函数式编程更是重中之...
  • Scala高阶函数使用总结

    千次阅读 2018-03-20 12:56:22
    函数Scala语言中有着举足轻重的地位,它和类,变量同样属于一等公民的地位,函数可以脱离类而独立存在,同时自己也可以作为参数传递给其他函数。 匿名函数scala&gt; val sayHello = (name: String) =&gt;...
  • scala高阶函数总结

    2015-01-20 11:57:05
    1、值函数将一个函数赋值给某个变量,此变量就是一个值函数scala> import scala.math._import scala.math._scala> val fun = sqrt _fun: Double => Double = <function1>scala> fun(25)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,739
精华内容 3,095
关键字:

scala高阶函数