Scala 【 10 函数式编程】

函数式编程

将函数赋值给变量

Scala 中的函数是一等公民，可以独立定义，独立存在，而且可以直接将函数作为值赋值给变量。

一等公民表现在： 1.可以传递、赋值 2.嵌套函数和匿名函数 3.具有高阶函数 4.偏应用 5.闭包

Scala的语法规定，将函数赋值给变量时，必须在函数后面加上空格和下划线。

代码语言：javascript复制

def sayHello(name:String){
    println("Hello, "   name)
}

// 注意这里是 空格   下划线
val sayHelloFunc = sayHello _

sayHelloFunc("Li")

匿名函数

Scala 中，函数也可以不需要命名，此时函数被称为匿名函数。

可以直接定义函数之后，将函数赋值给某个变量；也可以将直接定义的匿名函数传入其他函数之中 Scala 定义匿名函数的语法规则就是：

(参数名: 参数类型) => 函数体

代码语言：javascript复制

val sayHelloFunc = (name:String) => println("Hello,"   name)

高阶函数

Scala 中，由于函数是一等公民，因此可以直接将某个函数传入其他函数，作为参数。这个功能是极其强大的，也是 Java 这种面向对象的编程语言所不具备的。

接收其他函数作为参数的函数，也被称作高阶函数（higher-order function）。

代码语言：javascript复制

// example 1

val sayHelloFunc = (name:String) => println("Hello, "   name)

def greeting(func:(String) => Unit, name:String){
    func(name)
}

greeting(sayHelloFunc,"Li")

// example 2
// Array 中的 map 也是高阶函数
Array(1,2,3,4,5).map((num:Int) => num * num)

高阶函数的另外一个功能是将函数作为返回值。

代码语言：javascript复制

def getGreetingFunc(msg:String) = (name:String) => println(msg   ","   name)
// getGreetingFunc 就是一个高阶函数，接收一个 String 类型的 msg，返回一个函数，返回的函数会打印一行字符，返回的函数也需要接收一个 String 类型的 name。


val greetingFunc = getGreetingFunc("Hello")

greetingFunc("Li")
// 输出：Hello,Li


val greetingFuncHi = getGreetingFunc("Hi")

greetingFuncHi("Li")
// 输出：Hi,Li

// 对于不同参数的参数可以不同的输出。

高阶函数的类型推断

高阶函数可以自动推断出参数类型，而不需要写明类型。

而且对于只有一个参数的函数，还可以省去其小括号。

如果仅有的一个参数在右侧的函数体内只使用一次，则还可以将接收参数省略，并且将参数用_来替代。

代码语言：javascript复制

def greeting (func:(String) => Unit, name:String){
    func(name)
}

greeting((name:String) => println("Hello,"   name), "Li")

greeting((name) => println("Hello,"   name),"Li")
// 自动推断类型，所以可以省略 String 。

greeting(name => println("Hello,"   name) ,"Li")
// 只有一个参数，所以可以去掉小括号。


def triple(func:(Int) => Int) = {
    func(3)
}
// 这个会传入一个参数 3，而下面的 3 * _ 中的 _ 就是 3 。

triple(3 * _)

Scala的常用高阶函数

map: 对传入的每个元素都进行映射，返回一个处理后的元素。

代码语言：javascript复制

Array(1,2,3,4,5).map(2 * _)

foreach: 对传入的每个元素都进行处理，但是没有返回值。

代码语言：javascript复制

(1 to 9).map("*" * _).foreach(println _)

// 第一个 _ 是 1 to 9。
// foreach 中的 _ 是处理的结果。
// 这个意思是输出 9 行，第 i 行输出 i 个 * ，每次输出占一行。

filter: 对传入的每个元素都进行条件判断，如果对元素返回 true，则保留该元素，否则过滤掉该元素。

代码语言：javascript复制

(1 to 20).filter(_ % 2 == 0)

// 输出结果：scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

reduceLeft: 从左侧元素开始，进行 reduce 操作，即先对元素 1 和元素 2 进行处理，然后将结果与元素 3处理，再将结果与元素 4 处理，依次类推，即为 reduce。

代码语言：javascript复制

(1 to 4).reduceLeft(_ * _)
// 相当于 1 * 2 * 3 * 4

sortWith: 对元素进行两两相比，进行排序。

代码语言：javascript复制

Array(3,2,5,4,10,0).sortWith(_<_)
// 结果： 0 2 3 4 5 10
// Array[Int] = Array(0, 2, 3, 4, 5, 10)

闭包

闭包最简洁的解释：函数在变量不处于其有效作用域时，还能够对变量进行访问，即为闭包。

代码语言：javascript复制

def getGreetingFunc(msg:String) = (name:String) => println(msg   ","   name)

val greetingFuncHello = getGreetingFunc("Hello")

val greetingFuncHi = getGreetingFunc("Hi")

greetingFuncHello("Li")
greetingFuncHi("Li")

两次调用 getGreetingFunc 函数，传入不同的 msg，并创建不同的函数返回。然而，msg 只是一个局部变量，却在 getGreetingFunc 执行完之后，还可以继续存在创建的函数之中。

greetingFuncHello(“Li”)，调用时，值为 “hello” 的 msg 被保留在了函数体内部，可以反复的使用，这种变量超出了其作用域，还可以使用的情况，即为闭包。

Scala通过为每个函数创建对象来实现闭包，实际上对于 getGreetingFunc 函数创建的函数， msg 是作为函数对象的变量存在的，因此每个函数才可以拥有不同的 msg，Scala 编译器会确保上述闭包机制。

SAM转换

在 Java 中，不支持直接将函数传入一个方法作为参数，通常来说，唯一的办法就是定义一个实现了某个接口的类的实例对象，该对象只有一个方法；而这些接口都只有单个的抽象方法，也就是 single abstract method，简称为 SAM。

由于 Scala 是可以调用 Java 的代码的，因此当我们调用 Java 的某个方法时，可能就不得不创建 SAM 传递给方法，非常麻烦；但是 Scala 又是支持直接传递函数的。此时就可以使用 Scala 提供的，在调用 Java 方法时，使用的功能，SAM 转换，即将 SAM 转换为 Scala 函数。

要使用SAM转换，需要使用 Scala 提供的特性，隐式转换。

代码语言：javascript复制

import javax.swing._
import java.awt.event._

val button = new JButton("Click")

button.addActionListener(new ActionListener{
    override def actionPerformed(event:ActionEvent){
        println("Click Me!")
    }
})

// 测试 error: type mismatch
 button.addActionListener((event:ActionEvent) => println("Click Me!"))


implicit def getActionListener(actionProcessFunc:(ActionEvent) => Unit) = new ActionListener{
    override def actionPerformed(event:ActionEvent){
        actionProcessFunc(event)
    }
}

 button.addActionListener((event:ActionEvent) => println("Click Me!"))

Currying函数

Curring 函数指的是，将原来接收两个参数的一个函数，转换为两个函数，第一个函数接收原先的第一个参数，然后返回接收原先第二个参数的第二个函数。

在函数调用的过程中，就变为了两个函数连续调用的形式。

代码语言：javascript复制

def sum(a:Int,b:Int) = a   b
sum(1,1)

def sum2(a:Int) = (b:Int) => a   b
sum2(1)(1)

def sum3(a:Int)(b:Int) = a   b

return

Scala 中，不需要使用 return 来返回函数的值，函数最后一行语句的值，就是函数的返回值。

在 Scala 中，return 用于在匿名函数中返回值给包含匿名函数的带名函数，并作为带名函数的返回值。

使用return的匿名函数，是必须给出返回类型的，否则无法通过编译。

代码语言：javascript复制

def greeting(name:String) = {
    def sayHello(name:String):String = {
        return "Hello,"   name
    }
    sayHello(name)
}

scala java 编程算法

0 人点赞

Scala 【 10 函数式编程 】

函数式编程

将函数赋值给变量

匿名函数

高阶函数

高阶函数的类型推断

Scala的常用高阶函数

闭包

SAM转换

Currying函数

return

Scala 【 10 函数式编程】