Scala 高阶函数

最新推荐文章于 2021-08-04 22:48:29 发布
最新推荐文章于 2021-08-04 22:48:29 发布
阅读量667 收藏
点赞数 1
分类专栏： scala 文章标签： 函数 scala 高阶函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010521842/article/details/77898826
版权

Scala 高阶函数

Scala混合了面向对象和函数式的特性。在函数式编程语言中，函数是“头等公民”，可以像任何其他数据类型一样被传递和操作。每当你想要给算法传入明细动作时这个特性就会变得非常有用。

作为值的函数

在Scala中，函数是“头等公民”，就和数字一样。你可以在变量中存放函数：

import scala.math._

val num = 3.14
val fun = ceil _

这段代码将num设为3.14，fun设为ceil函数。

ceil参数后面的_意味着你确定指的是这个函数，而不是碰巧忘记给它送参数。

说明：从技术上讲，_将ceil方法转成了函数。在scala中，你无法直接操纵方法，而只能直接操纵函数。

匿名函数

在Scala中，你不需要给每一个函数命名，正如你不需要给每个数字命名一样。以下是一个匿名函数:

(x : Double) => 3 * x

这个函数将传给它的参数乘以3

你可以将这个函数存放到变量中：

val triple = (x : Double) => 3 * x

这就跟你用def一样：

def triple(x : Double) = 3 * x

带函数参数的函数

下面代码是一个函数作为参数的示例：

def valueAtOneQuarter(f : (Double) => Double) = f(0.25)

注意，这里的参数可以是任何接受Double并返回Double的函数。valueAtOneQuarter函数将计算那个函数在0.25位置的值。例如：

valueAtOneQuarter(ceil _)  // 1.0
valueAtOneQuarter(sqrt _)  // 0.5 (因为 0.5 * 0.5 = 0.25)

参数类型推断

当你将一个匿名函数传递给另一个函数或方法时，Scala会尽可能帮助你推断类型信息。举例来说，你不需要将代码写成：

valueAtOneQuarter((x:Double) => 3 * x)  // 0.75

由于valueAtOneQuarter方法知道你会传入一个类型为(Double)=>Double的函数，你可以简单写成：

valueAtOneQuarter((x) => 3 * x)

对于只有一个参数的函数，你可以略去参数外围的():

valueAtOneQuarter(x => x * 3)

如果参数在 => 右侧只出现一次，你可以用_替换掉它：

valueAtOneQuarter(3 * _)

请注意这些简写方式仅在参数类型已知的情况下有效。

val fun = 3 * _ // 错误：无法推断出类型
val fun = 3 * (_ : Double) // OK
val fun : (Double)=>Double = 3 * _ // OK,因为我们给出了fun的类型

柯里化

柯里化指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的 函数返回一个以原有第二个参数作为参数的函数。下面看一段代码：

def mul(x:Int) = (y:Int) => x * y
// 要计算两个数的乘积则调用mul(4)(5)

严格地讲，mul(4)的结果是函数(y:Int) => 4 *y。而这个函数又被应用到5，因此结果为20 。

Scala支持如下简写来定义柯里化：

def mul(x:Int)(y:Int) = x * y

下面写几个逆天的柯里化函数：

// 这个还比较简单，就是计算三个数连乘
def fun(x:Int)(y:Int)(z:Int) = x * y * z

// 下面这个就比较变态，其实和上面的用法一样
val fun = (a:Int) => (b:Int) => (c:Int) => a * b * c
// 和上面的代码一样，只不过定义了fun1的类型
val fun1:Int=>(Int=>(Int=>Int)) = (a:Int)=>(b:Int)=>(c:Int) => a * b * c

// 直线函数，通过f1(a)计算系数，通过f2(b)计算截距
def line(f1:Int=>Int)(a:Int)(f2:Int=>Int)(b:Int)(c:Int) = f1(a) * c + f2(b)
// 与上述功能一样
val line = (f1:Int=>Int) => (a:Int) => (f2:Int => Int) => (b:Int) => (c:Int) => f1(a) * c + f2(b)

控制抽象

在Scala中，我们可以将一系列语句归组成不带参数也没有返回值的函数。举例来说，如下函数在线程中执行某段代码：

def runInThread(block:() => Unit){
  new Thread{
    override def run(){
      block()
    }
  }.start()
}

这段代码以类型为()=>Unit的函数的形式给出。不过，当你调用该函数时，需要写一段不美观的()=>

runInThread{() => println("Hi");println("world")}

要想省略()=>,可以使用换名调用表示法，在参数声明和调用该函数参数的地方省略(),但是保留=>

def runInThread(block: => Unit){
  new Thread{
    override def run(){
      block
    }
  }.start()
}

调用就可以这样：

runInThread{println("Hi");println("world")}

Scala程序员可以构建控制抽象：看上去像是变成语言的关键字的函数。看下面例子：

def until(condition : => Boolean)(block : => Unit){
  if(!condition){
    block
    until(condition){block}
  }
}

// 调用until

var x = 10
until(x == 0){
  x -= 1
  println(x)
}

这样的函数参数有一个专业术语叫做换名调用参数。和一个常规(或者说换值调用)的参数不同，函数在被调用时，参数表达式不会求值。毕竟，在调用until时，我们不希望 x == 0被求值得到false。与之相反，表达式成为无参数的函数体，而函数被当做参数传递下去。

Scala中常用的高阶函数

1 map函数

所有的集合类型都存在map函数，例如Array的map函数的API具有如下形式：

//这里面采用的是匿名函数的形式，字符串*n得到的是重复的n个字符串，这是scala中String操作的一个特点
scala> Array("spark","hive","hadoop").map((x:String)=>x*2)
res3: Array[String] = Array(sparkspark, hivehive, hadoophadoop)

//省略匿名函数参数类型
scala> Array("spark","hive","hadoop").map((x)=>x*2)
res4: Array[String] = Array(sparkspark, hivehive, hadoophadoop)

//单个参数，还可以省去括号
scala> Array("spark","hive","hadoop").map(x=>x*2)
res5: Array[String] = Array(sparkspark, hivehive, hadoophadoop)

//参数在右边只出现一次的话，还可以用占位符的表示方式
scala> Array("spark","hive","hadoop").map(_*2)
res6: Array[String] = Array(sparkspark, hivehive, hadoophadoop)

List类型

scala> val list=List("Spark"->1,"hive"->2,"hadoop"->2)
list: List[(String, Int)] = List((Spark,1), (hive,2), (hadoop,2))

//写法1
scala> list.map(x=>x._1)
res20: List[String] = List(Spark, hive, hadoop)
//写法2
scala> list.map(_._1)
res21: List[String] = List(Spark, hive, hadoop)

scala> list.map(_._2)
res22: List[Int] = List(1, 2, 2)

Map类型

//写法1
scala> Map("spark"->1,"hive"->2,"hadoop"->3).map(_._1)
res23: scala.collection.immutable.Iterable[String] = List(spark, hive, hadoop)

scala> Map("spark"->1,"hive"->2,"hadoop"->3).map(_._2)
res24: scala.collection.immutable.Iterable[Int] = List(1, 2, 3)

//写法2
scala> Map("spark"->1,"hive"->2,"hadoop"->3).map(x=>x._2)
res25: scala.collection.immutable.Iterable[Int] = List(1, 2, 3)

scala> Map("spark"->1,"hive"->2,"hadoop"->3).map(x=>x._1)
res26: scala.collection.immutable.Iterable[String] = List(spark, hive, hadoop)

2 flatMap函数

//写法1
scala> List(List(1,2,3),List(2,3,4)).flatMap(x=>x)
res40: List[Int] = List(1, 2, 3, 2, 3, 4)

//写法2
scala> List(List(1,2,3),List(2,3,4)).flatMap(x=>x.map(y=>y))
res41: List[Int] = List(1, 2, 3, 2, 3, 4)

3 fitler函数

filter函数是对集合中的每个元素进行过滤，符合条件的所有元素组成新的集合。

scala> Array(1,2,4,3,5).filter(_>3)
res48: Array[Int] = Array(4, 5)

scala> List("List","Set","Array").filter(_.length>3)
res49: List[String] = List(List, Array)

scala> Map("List"->3,"Set"->5,"Array"->7).filter(_._2>3)
res50: scala.collection.immutable.Map[String,Int] = Map(Set -> 5, Array -> 7)

4 reduce函数

使用reduce我们可以处理列表的每个元素并返回一个值。通过使用reduceLeft和reduceRight我们可以强制处理元素的方向。（使用reduce方向是不被保证的）

//写法1
scala> Array(1,2,4,3,5).reduce(_+_)
res51: Int = 15

scala> List("Spark","Hive","Hadoop").reduce(_+_)
res52: String = SparkHiveHadoop

//写法2
scala> Array(1,2,4,3,5).reduce((x:Int,y:Int)=>{println(x,y);x+y})
(1,2)
(3,4)
(7,3)
(10,5)
res60: Int = 15

scala> Array(1,2,4,3,5).reduceLeft((x:Int,y:Int)=>{println(x,y);x+y})
(1,2)
(3,4)
(7,3)
(10,5)
res61: Int = 15

scala> Array(1,2,4,3,5).reduceRight((x:Int,y:Int)=>{println(x,y);x+y})
(3,5)
(4,8)
(2,12)
(1,14)
res62: Int = 15

5 fold函数

scala> Array(1,2,4,3,5).foldLeft(0)((x:Int,y:Int)=>{println(x,y);x+y})
(0,1)
(1,2)
(3,4)
(7,3)
(10,5)
res66: Int = 15

scala> Array(1,2,4,3,5).foldRight(0)((x:Int,y:Int)=>{println(x,y);x+y})
(5,0)
(3,5)
(4,8)
(2,12)
(1,14)
res67: Int = 15

scala> Array(1,2,4,3,5).foldLeft(0)(_+_)
res68: Int = 15

scala> Array(1,2,4,3,5).foldRight(10)(_+_)
res69: Int = 25

// /:相当于foldLeft
scala> (0 /: Array(1,2,4,3,5)) (_+_)
res70: Int = 15


scala> (0 /: Array(1,2,4,3,5)) ((x:Int,y:Int)=>{println(x,y);x+y})
(0,1)
(1,2)
(3,4)
(7,3)
(10,5)
res72: Int = 15

6 scan函数

//从左扫描，每步的结果都保存起来，执行完成后生成数组
scala> Array(1,2,4,3,5).scanLeft(0)((x:Int,y:Int)=>{println(x,y);x+y})
(0,1)
(1,2)
(3,4)
(7,3)
(10,5)
res73: Array[Int] = Array(0, 1, 3, 7, 10, 15)

//从右扫描，每步的结果都保存起来，执行完成后生成数组
scala> Array(1,2,4,3,5).scanRight(0)((x:Int,y:Int)=>{println(x,y);x+y})
(5,0)
(3,5)
(4,8)
(2,12)
(1,14)
res74: Array[Int] = Array(15, 14, 12, 8, 5, 0)

参考博文

http://blog.csdn.net/lovehuangjiaju/article/details/47079383

yanzhelee
关注
专栏目录
scala高阶函数
weixin_54707168的博客
01-29 424
高阶函数是指使用其他函数作为参数、或者返回一个函数作为结果的函数。在Scala中函数是“一等公民”，所以允许定义高阶函数。这里的术语可能有点让人困惑，我们约定，使用函数值作为参数，或者返回值为函数值的“函数”和“方法”，均称之为“高阶函数”。 最常见的一个例子是Scala集合类（collections）的高阶函数map val salaries = Seq(20000, 70000, 40000)val doubleSalary = (x: Int) => x * 2val newSalar
scala 高阶函数
qq_39674417的博客
12-23 748
高阶函数是指使用其他函数作为参数、或者返回一个函数作为结果的函数。在Scala中函数是“一等公民”，所以允许定义高阶函数。这里的术语可能有点让人困惑，我们约定，使用函数值作为参数，或者返回值为函数值的“函数”和“方法”，均称之为“高阶函数”。 最常见的一个例子是Scala集合类（collections）的高阶函数map val salaries = Seq(20000, 70000, 40000) val doubleSalary = (x: Int) => x * 2 val newSalar
Scala的高阶函数
qq_35573689的博客
04-18 218
如果从网上找到一些基础教程，有java基础肯定学的很快。但是我看了几个教程里好像都没有scala的进阶教程。下面说一下scala中的高阶函数。 几个重要的高阶函数有：值函数（作为值的函数），匿名函数，闭包，柯里化等 首先值函数和匿名函数比较好理解，值函数就是把一个函数赋值给一个变量，然后这个变量代表这个函数在程序中传递。 匿名函数就是，我们不用把函数赋值...
scala的高阶函数
njiang的专栏
01-10 635
scala高阶函数
scala高阶函数练习(非常重要)
weixin_42908473的博客
11-24 1107
1、定义一个高阶函数，按照指定的规则对集合里面的每个元素进行操作 比如: val arr = ArrayString 对集合中每个元素进行操作，得到集合每个元素的长度 val result = ArrayInt 2、定义一个高阶函数，按照指定的规则对集合中的所有元素进行聚合 val arr =ArrayInt 求得集合中的所有元素的和 val result = xx 3、定义一个高阶函数，按照指定的规则获取指定元素 val arr = Array[String](“zhangsan 20 3000”,“li
scala高阶函数练习题
柯南爱上指针的博客
01-30 1273
/** 练习题目1 * 编写函数values(fun:(Int)=>Int,low:Int,hight:Int) * * 该函数输出一个集合，对应给定区间内给定的给定函数的输入和输出，R比如values(x=>x*x,-5,5) * 应该产出一个对偶集合（-5，25），（-4，16），（-3，9）...（5，25） * */ def values(fu...
Scala高阶函数
Oak_Komorebi的博客
08-04 229
高阶函数 定义：高阶函数是指该函数的参数是函数，或者返回值是函数。 集合map高阶函数数用法： def map[B](f: String => B): scala.collection.TraversableOnce[B] def map[B](f: Int => B): scala.collection.TraversableOnce[B] # 这里f的参数是String还是Int取决于集合中数据的类型 val lst3=List(1,"a") def map[B](f: Any =&
scala的高阶函数(算子)
m0_59737088的博客
08-04 626
scala的高阶函数（算子） scala简介 1.Scala是一门多范式的静态类型编程语言,Scala支持【面向对象】和【函数式编程】 2.Scala源代码(.scala)会被编译成java字节码(.class)，然后运行在JVM之上，并可以调用现有的Java类库，实现两种语言的无缝对接 Scala匿名函数 知识补充： 1.不需要写def 函数名 2.不需要写返回类型，使用类型推导 3.= 变成 => 4. 如果有多行则使用{}包括，否则建议省略 //普通的函数 def test1(v
Scala>scala高阶函数
qq_44509920的博客
04-06 170
文章目录高阶函数作为值的函数匿名函数柯里化闭包 高阶函数 概念 Scala混合了面向对象和函数式的特性，我们通常将可以作为参数传递到方法中的表达式叫做函数。在函数式编程语言中，函数是“头等公民”，高阶函数包含：作为值的函数、匿名函数、闭包、柯里化等等。 作为值的函数 可以像任何其他数据类型一样被传递和操作的函数，每当你想要给算法传入具体动作时这个特性就会变得非常有用。 定义函数时格式：val ...
scala中高阶函数
迎接小天使
05-23 238
基本介绍 能够接受函数作为参数的函数，叫做高阶函数 (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之高阶函数
vinsuan93的专栏
06-24 451
一、概念 Scala混合了面向对象和函数式的特性，我们通常将可以做为参数传递到方法中的表达式叫做函数。在函数式编程语言中，函数是“头等公民”，高阶函数包含：作为值的函数、匿名函数、闭包、柯里化等等。 二、作为值的函数 可以像任何其他数据类型一样被传递和操作的函数，每当你想要给算法传入具体动作时这个特性就会变得非常有用。
scala中的高阶函数
coding笔记
06-14 641
版权申明：转载请注明出处。 文章来源：http://bigdataer.net/?p=332 排版乱？请移步原文获得更好阅读体验 1.scala中的函数 scala是一门面向对象和函数式编程相结合的语言，前面的文章已经讲了类、对象、继承等面向对象特有的语言特性，接下来将关注一下函数式编程的相关知识。在scala中，函数和变量一样，都是scala的一等公民。与函数相
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值