标签：模式匹配 from 高阶函数 方式 reducer hello 一个 mes partial
字符串高级操作：***** 非常重要
将函数赋值给变量/值
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"))
}
标签：模式匹配 from 高阶函数 方式 reducer hello 一个 mes partial
原文地址：https://www.cnblogs.com/green-frog-2019/p/11361504.html
