Scala学习之高阶函数

package com.lyzx.scalaLearn

class Day01 {
/**
* 函数也是一个值
* 1>可以赋值给一个变量
* 2>可以定义在一个函数的内部
* 3>可以当做参数传递给另一函数
* @param a
* @param b
* @param operator
* @return
*/
def mycalc(a:Int,b:Int,operator:Int):Int={
def add(one:Int,two:Int):Int ={
one+two
}

def min(one:Int,two:Int): Int ={
one-two
}

if(1 == operator)
add(a,b)
else
min(a,b)
}

/**
* 求第N个斐波那契数
* @param n n>=3
* @return
*/
def f2(n:Int): Int ={
var index = 3
def fib(one:Int,two:Int,x:Int): Int ={
if(x == index){
one+two
}else {
index += 1
fib(two,one+two,x)
}
}
val result = fib(0,1,n)
println("result:"+result)
result
}

def max(one:Int,two:Int):Int ={
if(one >= two) one
else two
}

def min(one:Int,two:Int):Int ={
if(one <= two) one
else two
}

/**
* 可以把函数当做参数一样传递
* 在定义传入的参数类型时需要定义函数的参数列表和返回值类型
* @param one
* @param two
* @param f
* @return
*/
def getNum(one:Int,two:Int,f:(Int,Int)=>Int): Int ={
f(one,two)
}

/**
* 这是一个多态函数也就泛型函数即可以操作多种数据类型
* @param arr
* @param target
* @param f
* @tparam T
* @return
*/
def findFirst[T](arr:Array[T],target:T,f:(T,T)=>Boolean):Int ={
def go[K](index:Int): Int ={
if(index >= arr.length)
-1
else if(f(arr(index),target))
index
else
go(index+1)
}
go(0)
}
}

case class X(id:Int,name:String,age:Int)

object Day01{

def main(args: Array[String]): Unit = {
val t = new Day01
//    val result = t.mycalc(11,1,-9)
//    println(result)

//    val count = t.f2(10)
//    println(count)

//    val getMin = t.getNum(12,33,t.min)
//    println(getMin)

val arr = Array(new X(1,"金刚狼",200),new X(2,"万磁王",60),new X(3,"琴",90))
val target = new X(3,"琴",90);

//可以把函数赋值给一个变量并传递给其他函数
val f = (x:X,y:X)=>{x.equals(y)}
val result = t.findFirst(arr,target,f)
println("result="+result)

val arr2 = Array(1,2,3,4,5)
//使用匿名函数，但是注意,在定义匿名函数的时候也要带上参数列表的类型
val result2 = t.findFirst(arr2,4,(x:Int,y:Int)=>{x == y})
println("result2="+result2)
}
}