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)
  }
}