Scala学习——函数高级操作

scala函数高级操作

一、字符串高级操作

多行字符串和插值

package top.ruandb.scala.Course06
object StringApp {

  def main(args: Array[String]): Unit = {
    val str =
      """
        |这是一个多行字符串
        |hello
        |lucy
        |lallalla
      """.stripMargin

    val say ="hello"
    val name = "lucy"
    println(say +": "+name )//传统字符串拼接
    println(s"$say: $name")//字符串插值操作
  }
}

二、匿名函数

package top.ruandb.scala.Course06

/**
  * 匿名函数
  * (参数名：参数类型 ...) => 函数体
  * 可以把匿名函数传给一个变量
  * 可以把匿名函数传给一个函数
  */
object FunctionApp {

  def main(args: Array[String]): Unit = {
    sayHello("lucy")
    a("lucy")
    say("lucy")
  }

  //常规函数
  def sayHello(name:String): Unit ={
    println(s"hello $name")
  }
  //匿名函数
  (name:String) => {println(s"hello $name")}
  //将匿名函数传给一个变量
  val a = (name:String) => {println(s"hello $name")}
  //将匿名函数传给函数
  def say =(name:String) => {println(s"hello $name")}
}

三、currying函数(柯里化函数)

柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。

package top.ruandb.scala.Course06
object FunctionApp {

  def main(args: Array[String]): Unit = {
      println(sum(1,9))
      println(sum1(1),(9))
  }
  //常规函数
  def sum(a:Int,b:Int): Int = a + b
  //currying函数
  def sum1(a:Int)(b:Int)=a + b
}

四、高阶函数

高阶函数（Higher-Order Function）就是操作其他函数的函数

package top.ruandb.scala.Course06
object FunctionApp {

  def main(args: Array[String]): Unit = {
    //调用test,传入printName函数和lucy
    test(printName,"lucy")
  }
  def test(f:String => Unit ,name:String) = f(name);
  def printName(name:String): Unit ={
    println(s"my name  is $name" );
  }

常用高阶函数

package top.ruandb.scala.Course06
object FunctionApp {

  def main(args: Array[String]): Unit = {
    val l =List(1,2,3,4,5,6,7,8,9);
    //map:逐个操作集合中的每个元素,所有集合类型都存在map函数
    l.map((x:Int) => x*10).foreach(println)
    //filter:过滤元素
    l.map( _ * 10).filter(_ > 30).foreach(println)//过滤大于30的元素
    //take：取前几个元素
    l.map( _ * 10).take(4).foreach(println)//取前4个元素
    //reduce:归纳、简化的意思,把容器中的元素作参数传给里面的二元匿名函数
    //函数体可以是求和，也可以是求积，等等，把容器中的元素归集起来返回。
    println(l.reduce(_ + _))  //45:相当于 1+2  3+3 6+4 .......
    println(l.reduceLeft(_-_))//-43: 相当于 1-2  -1-3 ......
    println(l.reduceRight(_-_))//5:相当于 1-(2-(3-(4-(5-(6-(7-(8-9)))))))
    //fold(折叠)函数将一种格式的输入数据转化成另外一种格式返回
    //fold操作需要从一个初始的“种子”值开始，并以该值作为上下文，处理集合中的每个元素。
    println(l.fold(10)(_*_))//3628800:相当于：((10*1)*2).......
    //foldLeft()，第一个参数为累计值，集合遍历的方向是从左到右
    println(l.foldLeft(10)(_-_))//-35:相当于((10-1)-2)-3........
    //foldRight()，第二个参数为累计值，集合遍历的方向是从右到左
    println(l.foldRight(10)(_-_))//-5:相当于1-(2-(3-(4-(5-(6-(7-(8-9))))))) - 10
    //max求最大
    println(l.max)
    //min求最小
    println(l.min)
    //sum求和
    println(l.sum)
    //flatten:可以把嵌套的结构展开.
    val f = List(List(1,2),List(3,4),List(5,6))
    println(f.flatten) //List(1, 2, 3, 4, 5, 6)
    //flatmap:结合了map和flatten的功能。接收一个可以处理嵌套列表的函数，然后把返回结果连接起来。
    println(f.flatMap(_.map(_*2)))//List(2, 4, 6, 8, 10, 12)
  }

}

五、偏函数

偏函数(Partial Function)，是一个数学概念它不是"函数"的一种, 它跟函数是平行的概念。

Scala中的Partia Function是一个Trait，其的类型为PartialFunction[A,B]，其中接收一个类型为A的参数，返回一个类型为B的结果。

package top.ruandb.scala.Course06
object FunctionApp {

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

    println(pf("1"))
  }
  //偏函数：被包在花括号内没有match的一组case语句
  def pf:PartialFunction[String,String]={
    case "1" => "one"
    case "2" => "two"
    case _ => "other"
  }

}