用示例看会scala函数

1.函数定义

a指你定义的参数即4，b指你定义的参数即3；Int是a和b的参数类型，最后的Int指的是整个函数的类型

   def fun (a:Int,b:Int):Int ={
      if (a>b)a else b
      }
    println(fun(4,3))

2.递归函数

同时这也是个嵌套函数，里面夹杂着if和else的逻辑结构，控制台输出后不难看出他是一个依次递减并相加的关系。

def fun2(num: Int): Int = {
  if (num == 1)
    1
  else
    num + fun2(num - 1)
}

println(fun2(3))

3.break

def fun3(num: Int) = {
  import scala.util.control.Breaks
  //方式一
  val loop = new Breaks
  loop.breakable(
    for (i <- 1 to num) {
      if (i == 4)
        loop.break()
      println(i)
    }
  )
  //方式二
  Breaks.breakable(
    for (i<-1 to num){
      if (i==4)
        Breaks.break()
      println(i)
    }
  )
}
fun3(8)
//方式三
def fun4(num:Int):Unit = {
  import scala.util.control.Breaks._
  breakable(
    for (i<- 1 to num){
      if (i==4)
        break()
      println(i)
    }
  )
}
fun4(5)

4.参数默认值的方法

def fun5(a:Int=10,b:Int=20):Int={
  a+b
}
println(fun5())

5.参数长度可变

def fun6(s:String*)={
  println(s)
}
fun6("a","b","c")

6.匿名函数

def fun7=(a:Int,b:Int)=>{a+b}
println(fun7(2,3))
def fun8=(a:Int,b:Int,c:Int)=>{a+b+c}
println(fun8(1,2,3))

7.高阶函数

//高阶函数
//1.使用函数作为参数
def f(a:Int,b:Int):Int={
  a+b
}
def fun9(f:(Int,Int)=>Int)={
  val a =100
  val b =200
  val result:Int = f(a,b)
  println(result)
}
fun9(f)

//字符串类型
def f1(a:String,b:String):String={
  a+b
}
def fun10(f1:(String,String)=>String) = {
  val a ="asd"
  val b ="sdjk"
  val result1:String =f1(a,b)
  println(result1)
}
  fun10(f1)//或者fun10((a:String,b:String)=>a+b),要把上面定义的f1函数给注掉

//函数作为返回值
def fun11(s:String):(Int,Int)=>Int= {
  if (s.length > 5) {
    def fun12(a: Int, b: Int):Int = {
      a + b
    }
    fun12
  }else {
    def fun13(a:Int,b:Int):Int={
      a-b
    }
    fun13
  }
}
val result =fun11("hello world")(2,4)
println(result)

//函数作为参数。函数作为返回值
//num % 2 ==0 返回一个加法的函数 num % 3 =0返回一个减法
def fun14(a:Int,b:Int):(Int,Int)=>Int={
  val sum = a+b
  if (sum%2==0){
    (c:Int,d:Int)=>c+d
  }else if (sum%3==0){
    (c:Int,d:Int)=>c-d
  }else{
    (c:Int,d:Int)=>0
  }
}
println(fun14(2,4)(3,5))
//方式二
def fun15(num:Int):Int={
  num %2
}
def fun16(num:Int):Int={
  num % 3
}
def fun17(a:Int,f:(Int)=>Int):(Int,Int)=>Int={
  val value = f(a)
  if (value ==0 ){
    def fun18(num1:Int,num2:Int):Int={
      num1+num2
    }
    fun18
  }else{
    (num1:Int,num2:Int)=>0
  }
}
val result2 = fun17(3,fun15)(3,4)

//打印恭喜中奖300
def fun19(f:(Int,Int)=>Int):(String,String)=>String={
  var sum =f(100,200)
  def fun20(a:String,b:String):String={
    a+sum+b
  }
  fun20
}
var str =fun19((a,b)=>{a+b})("您中奖了","恭喜您")
println(str)

8.函数柯理化

def fun21(a:Int,b:Int)(c:Int,d:Int):Int={
  a+b+c+d
}
val result3 = fun21(3,4)(5,6)
println(result3)
//隐式转换数据类型
implicit def double2Int(a:Double):Int = a.toInt
var a:Int =3.5
println(a)

9.部分函数/偏函数

//部分函数、偏函数
def showMsg(title:String,content:String,height:Double)={
  println(title+" "+content+height+"m")
}
showMsg("警告","水位下超过警戒线",0.8)
showMsg("警告","水位下超过警戒线",0.9)
showMsg("警告","水位下超过警戒线",1.0)
val title:String = "警告"
def showAlert=showMsg(title,_:String,_:Double)
showAlert("水位线超过警戒线",2.0)

def showInfo(a:Int,b:Int)={
  println(a+b)
}
def result4 =showInfo(4,_:Int)
result4(3)

def funPartial:PartialFunction[String,Int]={
  case "hello"=>1
  case "world"=>2
  case _=>3
}
val i:Int = funPartial("hello")
println(i)

def funPartial2:PartialFunction[Any,Int]={
  case i:Int =>i
  case _=>0
}
println(funPartial2(1))

var list = List("a",2,3,3.5)
val ints:List[Int] =list.collect(funPartial2)
ints.foreach(println)