scala 函数

函数的定义

package scala

object Demo12Fun1 {
  def main(args: Array[String]): Unit = {

    /**
      * 函数的定义
      * scala 可以在任何位置定义函数
      * 类中定义函数： 需要通过类的对象调用
      * object中定义的函数可以直接通过类名调用
      * 函数中定义的函数：可以直接通过函数名调用
      *
      */


    def fun(str: String): Unit = {
      println("fun:" + str)
    }

    //调用函数
    fun("scala")
    fun("java")

    /**
      * 函数的简写
      * 1、如果最后一行最为返回值，return可以省略
      * 2、如果代码只有一行括号可以省略
      * 3、返回值类型可以省略，scala会更具返回值自动推断
      * 4、如果参数为空，小括号可以省略
      */

    def fun1(i: Int, j: Int): Int = i + j


  }


}

高阶函数

package scala

object Demo13Fun2 {
  def main(args: Array[String]): Unit = {
    /**
      *面向对象编程：把一个对象传来传去
      * 1、将一个对象作为一个参数
      * 2、将对象作为返回值
      * 需要明确对象的类型，参数的类型，返回值的类型
      *
      * 面向函数编程（高阶函数）：将一个函数传来传去
      * 1、将一个函数作为一个参数----重点
      * 2、将一个函数作为一个返回值------忽略
      *
      * 需要明确函数的类型
      *
      * 函数的类型和参数、返回值有关，和函数名、方法体无关
      *
      * def stringToint (str:String ):Int =str.toInt
      * 这是一个参数为String，返回值为Int 类型的函数
      *
      * */
    def stringToint (str:String ):Int =str.toInt

    /**
      *以函数作为参数的
      *
      * String =>Int
      * 前面代表的是参数的类型  => 是关键字 相当于转换的关系
      * 后面代表的是返回值的类型
      *
      * */
    //fun 的参数是一个函数，是一个参数为String，返回值为Int类型的函数
    def fun(f:String =>Int): Unit ={

      //f 相当于函数的引用
      val i: Int = f("100")

      println("fun"+i)
    }

    //定义一个参数为String 返回值为Int的函数
    def sToi(s :String ):Int ={
    s.toInt
    }
    //调用 fun  需要一个参数为String，返回值为Int类型的函数
    fun(sToi)

    def sToi2(s:String ):Int ={
      s.toInt+100
    }
    fun(sToi2)

  }
}

lambda表达式

package scala

object Demo14Fun3 {
  def main(args: Array[String]): Unit = {
    /**
      * lambda 表达式 --- 对函数定义的简写-- 匿名函数
      *
      * */

    def stringToint(s:String ):Int ={
      s.toInt
    }
    /**
      *  使用lambda表达式
      *  (s:String )=>s.toInt
      *  => 左边是参数
      *  => 右边是返回值，返回值类型会自动推断
      *
      * */

    val f: String => Int = (s:String )=>s.toInt


    /**
      * 定义一个函数作为参数的函数
      */
    def fun (f:String =>Int )={
      val i = f("1000")
      println(i)
    }

    //lambda表达式的应用
    fun((s:String )=>{
      s.toInt
    })
    //如果lambda表达式的函数体只有一行，可以省略大括号
    fun((s:String )=>s.toInt)

    //lambda表达式的参数类型可以自动推断
    fun(s=>s.toInt)

    //如果lambda表达式的参数只使用了一次，可以使用下划线代替
    fun(_.toInt)

  }
}

以函数作为参数的应用

package scala

object Demo15Fun4 {
  def main(args: Array[String]): Unit = {

    /**
      * 以函数作为参数的应用
      *
      */

    val array = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

    //将数组中的元素都乘以2
    var i = 0
    while (i < array.length) {

      array(i) = array(i) * 2

      i += 1
    }

    //mkString 将数组或者集合按照一个分隔符拼接成一个字符串
    println(array.mkString(","))
    println("=" * 100)

    //使用scala高阶函数实现

    val array1 = Array(1,2,3,4,5,6,7,8,9)

    /**
      * map函数：一个一个的处理数组中的元素
      *
      * 循环数组中的元素，一个一个传给后面的函数，最终返回一个新的数组
      */
    //将数组中的与元素都乘以2
    val array3: Array[Int] = array1.map((i:Int )=> i * 2)
    println(array3.mkString(","))

    val strs = Array("1.1","2.3","4.3","5.1")
    //将数组中的元素转换成Double 类型
    val doubles: Array[Double] = strs.map((s:String )=> s.toDouble)
    println(doubles.mkString(","))


    /**
      * 将数组中的元素奇数乘以2，偶数加1
      *
      */

    val array4 = Array(1,2,3,4,5,6,7,8,9)
    var array5: Array[Int] =array4.map((i:Int )=>{
      if (i % 2 == 1){
          i * 2
      }else{
        i + 1
      }
    })
    println(array5.mkString(","))

  }
}

以函数作为返回值

package scala

object Demo16Fun5 {
  def main(args: Array[String]): Unit = {

    /**
      * 以函数作为返回值
      */
    def fun(s:String ):String => Int ={

      def f(s1:String):Int ={
        (s + s1).toInt
      }
      //返回一个函数
      f

    }

    //调用函数返回一个函数
    val stringToInt: String => Int = fun("100")

    //调用返回的函数
    val i: Int = stringToInt("1")
    println(i)    //    结果：1001

  }
}