十、函数式编程高级

ゝ一世哀愁。 2024-04-17 16:41 58阅读 0赞

# 一、偏函数(partial function) #

## 1、基本介绍 ##

*  在对符合某个条件，而不是所有情况进行逻辑操作时，使用偏函数是一个不错的选择
 *  将包在大括号内的一组case语句封装为函数，我们称之为**偏函数**，它只对会作用于指定类型的参数或指定范围值的参数实施计算，超出范围的值会忽略（未必会忽略，这取决于你打算怎样处理）
 *  **偏函数在Scala中是一个特质**PartialFunction

## 2、实例 ##

一个集合val list = List(1, 2, 3, 4, "abc") ，请完成如下要求:

将集合list中的所有数字+1，并返回一个新的集合

要求忽略掉 非数字 的元素，即返回的 新的集合 形式为 (2, 3, 4, 5)

object FunctionTest {
      def main(args: Array[String]): Unit = {
        val list = List(1, 2, 3, 4, "abc")
        //说明
        val addOne3= new PartialFunction[Any, Int] {
          def isDefinedAt(any: Any) = if (any.isInstanceOf[Int]) true else false
          def apply(any: Any) = any.asInstanceOf[Int] + 1
        }
        val list3 = list.collect(addOne3)
        println("list3=" + list3) //?
      }
    }

*  使用构建特质的实现类(使用的方式是PartialFunction的匿名子类)
 *  PartialFunction 是个特质(看源码)
 *  构建偏函数时，**参数形式 \[Any, Int\]是泛型，第一个表示参数类型，第二个表示返回参数**
 *  **当使用偏函数时，会遍历集合的所有元素，编译器执行流程时先执行isDefinedAt()如果为true ,就会执行 apply, 构建一个新的Int 对象返回**
 *  执行**isDefinedAt() 为false 就过滤掉这个元素**，即不构建新的Int对象.
 *  **map函数不支持偏函数，**因为map底层的机制就是所有循环遍历，无法过滤处理原来集合的元素
 *  collect函数支持偏函数

## 3、偏函数简化形式 ##

声明偏函数，需要重写特质中的方法，有的时候会略显麻烦，而Scala其实提供了简单的方法

object FunctionTest {
      def main(args: Array[String]): Unit = {
        def f2: PartialFunction[Any, Int] = {
          case i: Int => i + 1 // case语句可以自动转换为偏函数
        }
        //    简化形式一
        val list2 = List(1, 2, 3, 4,"ABC").collect(f2)
        println(list2)
        //    简化形式二
        val list3 = List(1, 2, 3, 4,"ABC").collect{ case i: Int => i + 1 }
        println(list3)
      }
    }

# 二、作为参数的函数 #

函数作为一个变量传入到了另一个函数中，那么该作为参数的函数的类型是：function1，即：(参数类型) => 返回类型

object FunctionTest {
      def main(args: Array[String]): Unit = {
        //说明:
        def plus_1(x: Int) = 3 + x
        def plus_2(x:Int):Int ={3 + x}
        //说明
        val result1 = Array(1, 2, 3, 4).map(plus_1)
        val result2 = Array(1, 2, 3, 4).map(plus_1(_))
        println(result1.mkString(","))
      }
    }

*  map(plus(\_)) 中的plus(\_) 就是将plus这个函数当做一个参数传给了map，\_这里代表从集合中遍历出来的一个元素。
 *  plus(\_) 这里也可以写成 plus 表示对 Array(1,2,3,4) 遍历，将每次遍历的元素传给plus的 x
 *  进行 3 + x 运算后，返回新的Int ，并加入到新的集合 result1中
 *  def map\[B, That\](f: A => B) 的声明中的 f: A => B 一个函数

# 三、匿名函数 #

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

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

*  (x: Double) => **3 \* x 就是匿名函数**
 *  **(x: Double) 是形参列表**， **=> 是规定语法表示后面是函数体**， **3 \* x 就是函数体，如果有多行，可以 \{\} 换行写**.
 *  **triple 是指向匿名函数的变量。**

# 四、高阶函数 #

**能够接受函数作为参数的函数，叫做高阶函数 (higher-order function)**。可使应用程序更加健壮。

## 1、基本使用 ##

object FunctionTest {
      def main(args: Array[String]): Unit = {
          val res = test(sum, 6.0)
          println("res = " + res)
        }
        //test 就是一个高阶函数，它可以接收f: Int=> Double
        def test(f: Int => Double, n1: Double) = {
          f(n1.toInt)
        }
        //sum 是接收一个 Int,返回一个Double
        def sum(d: Int): Double = {
          d + d
        }
    }

## 2、高阶函数可以返回函数类型 ##

def main(args: Array[String]): Unit = {
        val result = minusxy(3)(5)
        println(s"result = $result")
    //    分步执行
        val f1 = minusxy(3)
        val result2 = f1(5)
        println(s"result2 = $result2")
      }
      def minusxy(x: Int) = {
        (y: Int) => x - y
      }
    }

**（1）说明:** def minusxy(x: Int) = (y: Int) => x - y

函数名为 minusxy

该函数返回一个匿名函数：(y: Int) = > x -y

**（2）说明 ：** val result3 = minusxy(3)(5)

**minusxy(3)执行minusxy(x: Int)**得到 (y: Int) => 3 - y 这个匿名函

**minusxy(3)(5)执行 (y: Int) => x - y** 这个匿名函数

**也可以分步执行:** val f1 = minusxy(3); val res = f1(90)

# 五、参数(类型)推断 #

参数推断省去类型信息（在某些情况下\[需要有应用场景\]，参数类型是可以推断出来的，如  **list=(1,2,3) list.map()** map中函数参数类型是可以推断的)，同时也可以进行相应的**简写**。

**1、参数类型推断写法说明**

*  参数类型是可以推断时，**可以省略参数类型**
 *  当传入的函数，**只有单个参数时，可以省去括号**
 *  如果变量只在 => 右边只出现一次，可以用 \_来代替

val list = List(1, 2, 3, 4)
    println(list.map((x:Int)=>x + 1)) //(2,3,4,5)
    println(list.map((x)=>x + 1))
    println(list.map(x=>x + 1))
    println(list.map(_ + 1))
    val res = list.reduce(_+_)

**2、上述例子小结**

*  **map是一个高阶函数，因此也可以直接传入一个匿名函数**，完成map
 *  **当遍历list时，参数类型是可以推断出来的，可以省略数据类型 Int println(list.map((x)=>x + 1))**
 *  当传入的函数，**只有单个参数时，可以省去括号** println(list.map(x=>x + 1))
 *  如果变量只在**=>右边只出现一次，可以用\_来代替** println(list.map(\_ + 1))

# 六、闭包(closure) #

**1、基本介绍：**闭包就是**一个函数和与其相关的引用环境组合的一个整体(实体)。**

//1.用等价理解方式改写 2.对象属性理解
    def minusxy(x: Int) = (y: Int) => x - y
    //f函数就是闭包.
    val f = minusxy(20) 
    println("f(1)=" + f(1)) // 19
    println("f(2)=" + f(2)) // 18

**2、小结**

*  (y: Int) => x – y返回的是一个匿名函数 ，因为该函数引用到到函数外的 x,那么 该函数和x整体形成一个闭包,如：这里 val f = minusxy(20) 的f函数就是闭包
 *  你可以这样理解，返回函数是一个对象，而x就是该对象的一个字段，他们共同形成一个闭包
 *  当多次调用f时（可以理解多次调用闭包），发现使用的是同一个x, 所以x不变。
 *  在使用闭包时，主要搞清楚返回函数引用了函数外的哪些变量，因为他们会组合成一个整体(实体),形成一个闭包

**3、体会闭包的好处**

def makeSuffix(suffix:String)=(filename:String)=>{
          if(filename.endsWith(suffix)) filename
          else filename+suffix
        }
        val res1 = makeSuffix(".jpg")("test")
        val res2 = makeSuffix(".jpg")("test.jpg")
        println(s"res1 = $res1 , res2 = $res2")

*  返回的匿名函数和 makeSuffix (suffix string) 的 suffix 变量 组合成一个闭包,因为 返回的函数引用到suffix这个变量
 *  我们体会一下闭包的好处，如果使用传统的方法，也可以轻松实现这个功能，但是传统方法需要每次都传入 后缀名，比如 .jpg ,而闭包因为可以保留上次引用的某个值，所以我们传入一次就可以反复使用。大家可以仔细的体会一把！

# 七、函数柯里化(curry) #

**1、基本介绍**

*  函数编程中**，接受多个参数的函数都可以转化为接受单个参数的函数**，这个转化过程就叫柯里化
 *  柯里化**就是证明了函数只需要一个参数而已。**其实我们刚才的学习过程中，已经涉及到了柯里化操作。
 *  不用设立柯里化存在的意义这样的命题。**柯里化就是以函数为主体这种思想发展的必然产生的结果**。(即：柯里化是面向函数思想的必然产生结果)

**2、实例**

object FunctionTest {
      def main(args: Array[String]): Unit = {
    //    编写一个函数，接收两个整数，可以返回两个数的乘积，要求:
        val n1 = 10
        val n2 = 20
        println(mul1(n1,n2))
        println(mul2(n1)(n2))
        println(mul3(n1)(n2))
      }
    //  使用常规的方式完成
      def  mul1(n1:Int,n2 :Int):Int={
        n1 * n2
      }
    //  使用闭包的方式完成
      def mul2(n1:Int)=(n2:Int)=>{
        n1 * n2
      }
    //  使用函数柯里化完成
      def mul3(n1:Int)(n2:Int) = n1 * n2
    }

**3、比较两个字符串在忽略大小写的情况下是否相等，注意，这里是两个任务：**  
全部转大写（或小写）

比较是否相等

针对这两个操作，我们用一个函数去处理的思想，其实也变成了两个函数处理的思想（柯里化）

**方式一、**

//方式1: 简单的方式,使用一个函数完成.
    def eq2(s1: String)(s2: String): Boolean = {
        s1.toLowerCase == s2.toLowerCase
    }

**方式2：使用稍微高级的用法(隐式类)**

object FunctionTest {
      def main(args: Array[String]): Unit = {
    //    比较两个字符串在忽略大小写的情况下是否相等，
        val s1 = "a"
        val s2 = "b"
        //
        val b2 = s1.checkEq(s2)(eq)
        println(b2)
    //下面三种写法等价，并且可以表示一个演变过程
        s1.checkEq(s2)((s1:String,s2: String) =>s1.equals(s2))
        s1.checkEq(s2)((s1,s2) =>s1.equals(s2))
        s1.checkEq(s2)(_.equals(_))
      }
      //接收两个字符串，比较是否相等
      def eq(s1: String, s2: String): Boolean = {
        s1.equals(s2)
      }
    //  隐式类，
    //  TestEq(s: String)，字符串可以调用该隐式类中的方法
      implicit class TestEq(s: String) {
    //  接收一个String值，
    //  将比较字符串分散成两步执行
    //  checkEq(ss: String)完成将字符串完成大小写转换任务
    //  f 接收两个字符串,完成比较字符串的任务
        def checkEq(ss: String)(f: (String, String) => Boolean): Boolean = {
          f(s.toLowerCase, ss.toLowerCase)
        }
      }
    }

# 八、控制抽象 #

**1、控制抽象基本介绍**

**（1）控制抽象是这样的函数，满足如下条件**

*  参数是函数
 *  函数参数没有输入值也没有返回值

def myRunInThread(f1: () => Unit) = {
          new Thread {
            override def run(): Unit = {
              f1()
            }
          }.start()
        }
        myRunInThread {
          () => println("干活咯！5秒完成...")
            Thread.sleep(5000)
            println("干完咯！")
        }

**（2）上例简化处理，省略()，如下形式**

def myRunInThread(f1:  => Unit): Unit = {//说明 
          new Thread {
            override def run(): Unit = {
              f1
            }
          }.start()
        }
        myRunInThread {
           println("干活咯！5秒完成...")
            Thread.sleep(5000)
            println("干完咯！")
        }

**2、进阶用法：实现类似while的until函数**

var x = 10
    def until(condition: => Boolean)(block: => Unit): Unit = {
      //类似while循环，递归
      if (!condition) {
        block
        until(condition)(block)
      }
    }
    until(x == 0) {
      x -= 1
      println("x=" + x)
    }