Scala函数高级操作

字符串高级操作：***** 非常重要

将函数赋值给变量/值
def sayHello(name:String): Unit = {
　　println(s"Hello:$name")
}

object StringApp extends App {
　　val s = "Hello:PK"
　　val name = "PK"
　　//println(s + name)

　　println(s"Hello:$name")

　　val team = "AC Milan"
　　//插值
　　println(s"Hello:$name, welcome to $team")

　　多个字符串的写法：
　　val b =
　　　　"""
　　　　　|这是一个多行字符串
　　　　　|hello
　　　　　|world
　　　　　|PK
　　　　""".stripMargin
　　println(b)
}

匿名函数
　　(参数名:参数类型) => 函数体

没有大括号,()是必须的
有大括号, ()是可以去掉的

scala> (x:Int) => x+1
res0: Int => Int = <function1>

scala> {(x:Int) => x+1}
res1: Int => Int = <function1>

scala> val m1 = (x:Int) => x+1
m1: Int => Int = <function1>

scala> m1(10)
res2: Int = 11

scala> def add(x:Int, y:Int)=>{x+y}
add: (Int, Int) => Int

scala> add(2,3)
res3: Int = 5

scala> map(x=>(x,1))

currying函数：颗粒化的方式

object FunctionApp extends App {
　　//将原来接收两个参数的一个函数，转换成2个，这就是颗粒化。
　　

　　def sum(a:Int, b:Int) = a+b
　　println(sum(2,3))

　　颗粒化的方式：
　　def sum2(a:Int)(b:Int) = a + b
　　println(sum2(2)(3))
}

高阶函数 *****

主要有map、filter、flatmap、foreach、reduce等

map: 是对每个元素进行某个操作
flatMap: 先压扁到一起，再做map操作
foreach：遍历每一个元素

object FunctionApp extends App {

　　val l = List(1,2,3,4,5,6,7,8)

　　//map：逐个去操作集合中的每个元素
　　l.map((x:Int) => x+1) //给l的LIST里的每个元素+1

　　l.map((x) => x * 2) //能自己推导类型
　　l.map(x => x * 2) //去掉括号的前提是括号里面是一个元素就可以省略
　　l.map( _ * 2).foreach(println) //表示每个元素都乘以2，foreach：遍历每一个元素，不使用foreach的话在IDEA里是不能打印的。

　　l.map(_*2).filter(_ > 8).foreach(println) //取出大于8的

　　l.take(4) //取出集合的前4个元素

　　//1+2=3 3+3=6 6+4=10 10+5=15
　　l.reduce(_+_) //集合的元素两两相加

　　l.reduceLeft(_-_) //-34
　　l.reduceRight(_-_) //-4

　　l.fold(0)(_-_)
　　l.foldLeft
　　l.foldRight

　　l.max
　　l.min
　　l.sum

scala> val f = List(List(1,2),List(3,4),List(5,6))
f: List[List[Int]] = List(List(1,2), List(3,4), List(5,6))

scala> f.flatten //把所有数据压扁到一起
res20: List[Int] = List(1, 2, 3, 4, 5, 6)

// flatMap
scala> f.map(x=>x)
res22: List[List[Int]] = List(List(1,2), List(3,4), List(5,6))

scala> f.map(_.map(_*2))
res23: List[List[Int]] = List(List(2,4), List(6,8), List(10,12))

scala> f.flatMap(_.map(_*2)) //先把数据打扁在一起，然后在调用map。
res24: List[Int] = List(2, 4, 6, 8, 10, 12)

cat hello.txt
hello,world,hell,hello

　　val txt = scala.io.Source.fromFile("/Users/rocky/imooc/hello.txt").mkString //从文件里读取数据并把数据转换成字符串

　　println(txt)

　　val txts = List(txt)
　　txts.flatMap(_.split(",").map(x => (x,1))).forreach(println) //把数据按逗号进行分割以后再打扁
}

偏函数：PartialFunction[A,B]
A: 输入参数类型
B：输出参数类型
常用作输入模式匹配

/**
* 偏函数：被包在花括号内没有match的一组case语句
*/

object PartitalFunctionApp extends App {
　　//match的写法
　　val names = Array("Akiho Yoshizawa", "YuiHatano", "Aoi Sola")
　　val name = names(Random.nextInt(names.length)) //随机取一个名字

　　name match {
　　　　case "Akiho Yoshizawa" => println("吉老师...")
　　　　case "YuiHatano" => println("波老师...")
　　　　case _ => println("真不知道你们在说什么...")
　　}

　　//偏函数的写法：
　　def sayChinese:PartitalFunction[String,String] = { //穿进去一个入参，输出一个出参。
　　　　case "Akiho Yoshizawa" => "吉老师..."
　　　　case "YuiHatano" => "波老师...")
　　　　case _ => "真不知道你们在说什么..."
　　}

　　println(sayChinese("Akiho Yoshizawa"))

}