6.Scala-高阶函数

本是古典何须时尚 2024-04-20 09:05 39阅读 0赞

# 第6章 高阶函数 #

## 6.1 作为参数的函数 ##

函数作为一个变量传入到另一个函数中，那么该作为参数的函数的类型是：function1，即：

（参数类型）=> 返回值

//6.1 作为参数的函数
    def plus(x: Int) = 3 + x
    val result1 = Array(1, 2, 3, 4).map(plus(_))
    println(result1.mkString(","))

尖叫提示：带有一个参数的函数的类型是function1，带有两个参数的是function2，以此类推。

笔记：

//6.1 作为参数的函数
    def match1(): Unit = {
      def plus(x: Int) = 3 + x
      val result1 = Array(1, 2, 3, 4).map(plus(_))
      println(result1.mkString(",")) //4,5,6,7
    }
    match1()

## 6.2 匿名函数 ##

即没有名字的函数，可以通过函数表达式来设置匿名函数。

val triple = (x: Double) => 3 * x
    println(triple(3))
    
    //使用方法：
    Array(3.14, 1.42, 2.0).map(triple)
    //包含在()中
    Array(3.14, 1.42, 2.0).map((x: Double) => 3 * x)
    // 包含在{}中
    Array(3.14, 1.42, 2.0) map { (x: Double) => 3 * x }

笔记：

//6.2 匿名函数
    def match2(): Unit = {
      val triple = (x: Double) => 3 * x
      println(triple(3)) //9.0
    
      //使用方法：
      println(Array(3.14, 1.42, 2.0).map(triple).mkString(", ")) //9.42, 4.26, 6.0
      //包含在()中
      println(Array(3.14, 1.42, 2.0).map((x: Double) => 3 * x).mkString(", "))
      // 包含在{}中
      println(Array(3.14, 1.42, 2.0) map { (x: Double) => 3 * x } mkString(", "))
    }
    match2()

## 6.3 高阶函数 ##

能接受函数作为参数的函数，叫做 高阶函数。

1）高阶函数的使用

def highOrderFunction1(f: Double => Double) = f(10)
    def minus7(x: Double) = x -7
    val result2 = highOrderFunction1(minus7)
    println(result2)

2）高阶函数同样可以返回函数类型

def minusxy(x: Int) = (y: Int) => x - y
    val result3 = minusxy(3)(5)
    println(result3)

![1604514-20190702144625943-1705281756.png][]

## 6.4 参数（类型）推断 ##

// 传入函数表达式
    valueAtOneQuarter((x: Double) => 3 * x)
    // 参数推断省去类型信息
    valueAtOneQuarter((x) => 3 * x)
    // 单个参数可以省去括号
    valueAtOneQuarter(x => 3 * x)
    // 如果变量旨在=>右边只出现一次，可以用_来代替
    valueAtOneQuarter(3 * _)

## 6.5 闭包 ##

闭包就是一个函数把外部的那些不属于自己的对象也包含(闭合)进来了。

def minusxy(x : Int) = (y : Int) => x - y
    println(minusxy(10)(20))

这就是一个闭包

1) 匿名函数(y : Int) => x - y 嵌套在函数 minusxy 中。

2) 匿名函数(x : Int) => x - y 使用了外部变量、mulBy 的局部变量 x。不是全局变量

3) 函数 minusxy 返回了引用局部变量的匿名函数。

再举一个例子：

def minusxy(x: Int) = (y: Int) => x - y
    val f1 = minusxy(10)
    val f2 = minusxy(10)
    println(f1(3) + f2(3))

此处 f1，f2 这两个函数就叫闭包 。

## 6.6 柯里化 ##

函数编程中，接受多个参数的函数都可以转化为接受单个参数的函数，

这个转化过程就叫柯里化，柯里化就是证明了函数只需要一个参数而已。

**1）柯里化示例**

// 传统定义两个参数
    def mul(x:Int, y: Int) = x * y
    println(mul(6,7))
    
    // 柯里化定义，使用到了闭包
    def mulOneAtATime(x: Int) = (y: Int) => x * y
    println(mulOneAtATime(6)(7))
    
    // Scala 中可以简写
    def mulOneAtATime(x: Int)(y: Int) = x * y
    println(mulOneAtATime(10)(8))

**2）柯里化的应用**

**比较两个字符串再忽略大小写的情况下是否相等，注意，这里是两个任务：**

**1、全部转大写（或小写）**

**2、比较是否相等**

**针对这两个操作，我们用一个函数去处理的思想，其实无意间也变成了两个函数处理的思想。**

**示例如下：**

val a = Array("Hello", "World")
    val b = Array("hello", "world")
    // def corresponds[B](that: GenSeq[B])(p: (A,B) => Boolean): Boolean
    println(a.corresponds(b)(_.equalsIgnoreCase(_)))

corresponds 函数的定义使用了柯里化

源码如下:

def corresponds[B](that: GenSeq[B])(p: (A,B) => Boolean): Boolean = {
        val i = this.iterator
        val j = that.iterator
        while (i.hasNext && j.hasNext)
          if (!p(i.next(), j.next()))
            return false
    
        !i.hasNext && !j.hasNext
      }

## 6.7 控制抽象 ##

控制抽象是一类函数：

1、参数是函数。

2、函数参数没有输入值也没有返回值。

**1）使用示例：**

def runInThread(block: () => Unit) {
    　　new Thread {
    　　　　override def run() { block() }
    　　}.start()
    }
    // 传入函数
    runInThread { () => println("Hi") ; Thread.sleep(10000); println("Bye") }
    () = > 有些多余，可以使用换名调用来表示，省略（）保留=>
    // 这种叫控制抽象函数 (看上去像是编程语言关键字的函数)
    def runInThread(block: => Unit) {
    　　new Thread {
    　　　　override def run() { block }
    　　}.start()
    }
    // 优雅的传入
    runInThread { println("Hi") ; Thread.sleep(1000); println("Bye") }
    
    
    //可以定义类似于 while 的 until 函数
    def until(condition: => Boolean)(block: => Unit) {
    　　if (!condition) {
    　　　　block
    　　　　until(condition)(block)
    　　}
    }
    
    var x = 10
    until (x == 0) {
                
    　　x -= 1
    　　println(x)
    }

笔记：

//6.7 控制抽象
    def runOnThread(f1:() => Unit): Unit = {
      new Thread{
        override def run(): Unit = {
          f1()
        }
      }.start()
    }
    
    runOnThread({
      () => println("干活！")
        Thread.sleep(5000)
        println("活干完了！")
    })
    
    //    () => 1; 2; 3 + 1

转载于:https://www.cnblogs.com/LXL616/p/11122087.html

[1604514-20190702144625943-1705281756.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/9a15827f9e1b44bf8ce084e6aabedf58.png