scala之函数篇

目录

def关键字

函数的定义：（=>）

柯里化技术

偏函数

成员函数和本地函数

匿名函数和高阶函数

fllter和foreach

递归函数

lazy懒值   

---

def关键字

scala通过def 关键字来定义函数.形式: def 方法名称（参数列表）：方法的返回值类型 = 方法体

      方法可以转换成函数 方法名称 _

函数的定义：（=>）

               方式一：
                  (函数的参数列表) => 函数体
               val add = (x: Int, y: Int) => x + y
        
               方式二：
                  (函数的参数类型列表)=> 函数的返回值类型 = (函数的参数变量引用) => 函数体
              val add:(Int, Int) => Int = (a, b) => a + b
              val prtf: String => Unit = msg => println(msg)

def f3()={ 100 }    //> f3: ()Int   。scala可以根据返回值自动推断出函数的类型，不需要显示声明

def f5(){ 100 }   //> f5: ()Unit  scala函数如果没有=号，则返回值类型一律为Unit(),所以建议写函数时，别忘了加=

def f8(a:String,b:String="?")={ a+b }        //--scala函数的默认参数机制，任何类型都可以使用默认参数机制

def f（str: String, a: Any*） //--scala也支持可变参数,可变参数本质会转成集合类型,注意:可变参数必须位于参数列表的最后

柯里化技术

1.scala底层支持柯里化技术，允许将接收多个参数的函数转变为接收单一参数的函数

2.scala的柯里化技术允许用户自建立控制结构。柯里化技术是函数式编程语言的技术

 def method4(a: Int)(b: Int, c: Int)    method(0)(4, 5)

//--自建的控制结构：重点留意这种形式,前面的参数都是普通参数，后面的参数是匿名函数
def f32(a:Int,b:Int)(f:(Int,Int)=>Int){f(a,b)}  //> f32(2,3)(_+_)
def f33(a:Int)(b:Int,f:(Int,Int)=>Int){f(a,b)}  //> f33: (a: Int)(b: Int, f: (Int, Int) => Int)Unit

偏函数

PartialFunction[参数类型，函数返回值类型]
       def method5 :PartialFunction[Any, String] = {
           case x: Int => x * 10
       }

成员函数和本地函数

class Person {

//--定义在类内部的函数，称为成员函数

def say()={

      println("hello")

      //--定义在函数内的函数，成为本地函数，本地函数无法通过对象直接调用

      def speak()={

            println("say world")

      }

           }

}

匿名函数和高阶函数

1.scala语言既是面向对象的语言，也是面向函数的语言(函数是一等公民)、

2.匿名函数通用的化简规则1:如果参数的类型可以推断出，则类型可以省略

                                         2:如果匿名函数的参数只有一个，则参数的()可以省略
def f1(a:Int,b:Int)={a+b}    //--定义普通函数 > f1: (a: Int, b: Int)Int 
val f2=(a:Int,b:Int)=>{a+b} //--定义匿名函数,匿名函数没有函数名,匿名函数和方法体的连接符是  =>，把匿名函数赋值给f2,

def f3(a:Int,b:Int,f:(Int,Int)=>Int)={ //--把匿名函数当做参数进行传递，此函数称为高阶函数,这是函数式编程的特点
      f(a,b)
  }                                          
 //--要求调用f3,完成2*3的计算
f3(2,3,(a:Int,b:Int)=>{a+b})                    //> res1: Int = 5
f3(2,3,(a,b)=>a+b)                              //> res2: Int = 5
f3(2,3,_+_)    // 最终极的化简规则：可以通过_(占位符)来化简。 可以通过_来代替参数 ,Int = 5

 

fllter和foreach

val a1=Array(1,2,3,4)                           //> a1  : Array[Int] = Array(1, 2, 3, 4)
a1.filter {(x:Int)=>{x>2} }       //--通过指定的匿名函数实现过滤               //> res9: Array[Int] = Array(3, 4)
a1.filter {x=>x>2 }                             //> res10: Array[Int] = Array(3, 4)
a1.filter {_>2 }                                //> res11: Array[Int] = Array(3, 4)
a1.foreach { (x:Int) =>{println(x)} }       //--通过指定的匿名函数遍历数组    //> 1 2 3 4 
a1.foreach { x=>println(x) }                    //> 1 2 3 4 
a1.foreach { println(_) }                       //> 1 2 3 4 

递归函数

1.scala写递归函数，必须显示的声明函数的返回值类型，不能用自动推断

2.写递归的技巧:掌握两要素 ①找出递归函数的结束条件 ②找出函数关系(重点)

3.scala的递归函数，结束条件的返回值必须加return关键字返回

  //--用递归函数判断斐波那契数列第n项的数字是多少
  //--2 3 5 8 13
  //--函数关系:f(n)=f(n-1)+f(n-2)
  //--结束条件:f(0)=2 f(1)=3
  
  def f1(n:Int):Int={
      if(n==0) return 2
      if(n==1) return 3
      else f1(n-1)+f1(n-2)
  }                                               
  

lazy懒值   

1.lazy懒值声明之后，并不是马上赋值的，待真正被调用时才会赋值

2.lazy只能修饰常量val,不能修饰变量var

val v1=100                                      //> v1  : Int = 100
lazy val v2=100                                 //> v2: => Int
println(v2)                                     //> 100