Scala高阶语法
高阶函数
函数能够作为参数进行传递和回来值进行回来
//传一个a乘b 就回来一个函数，逻辑是完成两数相乘
//传一个a*b 回来一个函数，逻辑是完成两数相乘
//传一个axb 回来一个函数，逻辑是完成两数相乘
def funTest6(str:String,fun:(String)=>Int):(Int,Int)=>Int = {
val i: Int = fun(str)
i match {
case 0 => (a,b)=>a+b
case 1 => (a,b)=>a-b
case 2 => (a,b)=>a*b
case 3 => (a,b)=>a/b
}
}
val function: (Int, Int) => Int = funTest6("a*b", (s) => {
if (s.contains("*") || s.contains("乘")) {
2
} else {
0
}
})
println(function(2, 3))
匿名函数
没有姓名的函数便是匿名函数。
例如：
(x:Int)=>{函数体}
x：表明输入参数类型；Int：表明输入参数类型；函数体：表明详细代码逻辑```
传递匿名函数至简准则：
1. 参数的类型能够省掉，会依据形参进行主动的推导
2. 类型省掉之后，发现只要一个参数，则圆括号能够省掉；其他状况：没有参数和参数超越 1 的永久不能省掉圆括号。
3. 匿名函数假如只要一行，则大括号也能够省掉
4. 假如参数只呈现一次，则参数省掉且后边参数能够用_替代
操练1：传递的函数有一个参数
代码示例：
```Scala
def main(args: Array[String]): Unit = {
// （1）界说一个函数：参数包含数据和逻辑函数
def operation(arr: Array[Int], op: Int => Int): Array[Int] = {
for (elem <- arr) yield op(elem)
}
// （2）界说逻辑函数
def op(ele: Int): Int = {
ele + 1
}
// （3）规范函数调用
val arr = operation(Array(1, 2, 3, 4), op)
println(arr.mkString(","))
// （4）选用匿名函数
val arr1 = operation(Array(1, 2, 3, 4), (ele: Int) => {
ele + 1
})
println(arr1.mkString(","))
// （4.1）参数的类型能够省掉，会依据形参进行主动的推导;
val arr2 = operation(Array(1, 2, 3, 4), (ele) => {
ele + 1
})
println(arr2.mkString(","))
// （4.2）类型省掉之后，发现只要一个参数，则圆括号能够省掉；其他情
况：没有参数和参数超越 1 的永久不能省掉圆括号。
val arr3 = operation(Array(1, 2, 3, 4), ele => {
ele + 1
})
println(arr3.mkString(","))
// (4.3) 匿名函数假如只要一行，则大括号也能够省掉
val arr4 = operation(Array(1, 2, 3, 4), ele => ele + 1)
println(arr4.mkString(","))
//（4.4）假如参数只呈现一次，则参数省掉且后边参数能够用_替代
val arr5 = operation(Array(1, 2, 3, 4), _ + 1)
println(arr5.mkString(","))
}
}
操练二：传递的函数有两个参数
代码示例：
object TestFunction {
def main(args: Array[String]): Unit = {
def calculator(a: Int, b: Int, op: (Int, Int) => Int): Int
= {
op(a, b)
}
// （1）规范版
println(calculator(2, 3, (x: Int, y: Int) => {x + y}))
// （2）假如只要一行，则大括号也能够省掉
println(calculator(2, 3, (x: Int, y: Int) => x + y))
// （3）参数的类型能够省掉，会依据形参进行主动的推导;
println(calculator(2, 3, (x , y) => x + y))
// （4）假如参数只呈现一次，则参数省掉且后边参数能够用_替代
println(calculator(2, 3, _ + _))
}
}
偏函数
偏函数是一个特质 ,用来专门处理某种数据类型! [留意能够一起处理多种数据类型]
偏函数的界说：
val second: PartialFunction[List[Int], Option[Int]] = {
case x :: y :: _ => Some(y)
}
注：该偏函数的功用是回来输入的 List 调集的第二个元素
事例：将调集中的一切的Int类型的数据都加上1
代码示例：
// 办法一 过滤器办法
val list = List(1, 2, 3, 4, "hello")
val res: List[Int] = list.filter(x => x.isInstanceOf[Int]).map(x => x.asInstanceOf[Int] + 1)
res.foreach(println)
// 办法二 匹配办法
val res2: List[Any] = list.map(x => x match {
case x: Int => x + 1
case _ =>
})
res2.filter(x => x.isInstanceOf[Int]).foreach(println)
// 办法三 运用偏函数 泛型1 输入的数据类型 泛型2 要处理的数据类型
val pp = new PartialFunction[Any,Int] {
// 回来true
override def isDefinedAt(x: Any) = {
x.isInstanceOf[Int]
}
// 履行下一个办法
override def apply(v1: Any) = {
v1.asInstanceOf[Int]+1
}
}
// list.map(pp).foreach(println)
list.collect(pp).foreach(println)
偏函数原理
上述代码会被 scala 编译器翻译成以下代码，与一般函数比较，仅仅多了一个用于参数查看的函数——isDefinedAt，其回来值类型为 Boolean。
val second = new PartialFunction[List[Int], Option[Int]] {
//查看输入参数是否合格
override def isDefinedAt(list: List[Int]): Boolean = list match
{
case x :: y :: _ => true
case _ => false
}
//履行函数逻辑
override def apply(list: List[Int]): Option[Int] = list match
{
case x :: y :: _ => Some(y)
}
}
偏函数的履行流程
- 遍历list中的每个元素
- 调用 val e = if (isDefinedAt)
- 每得到一个e 就会将e存储在一个新的调集中回来运用偏函数就不要运用map办法了
偏函数的简写办法
val list = List(2, 4, 6, 8, "cat")
//界说一个偏函数
def myPartialFunction: PartialFunction[Any, Int] = {
case x: Int => x * x
}
list.collect(myPartialFunction).foreach(println)
// 简写办法
list.collect({
case x:Int=>x*x
}).foreach(println)
偏函数总结
- 运用构建特质的完成类(运用的办法是PartialFunction的匿名子类)
- PartialFunction 是个特质(看源码)
- 构建偏函数时，参数办法 [Any, Int]是泛型，第一个表明参数类型，第二个表明回来参数
- 当运用偏函数时，会遍历调集的一切元素，编译器履行流程时先履行isDefinedAt()假如为true ,就会履行 apply, 构建一个新的Int 目标回来
- 履行isDefinedAt() 为false 就过滤掉这个元素，即不构建新的Int目标.
- map函数不支撑偏函数，由于map底层的机制便是一切循环遍历，无法过滤处理本来调集的元素
- collect函数支撑偏函数
办法匹配
办法匹配语法中，选用 match 关键字声明，每个分支选用 case 关键字进行声明，当需求匹配时，会从第一个 case 分支开端，假如匹配成功，那么履行对应的逻辑代码，假如匹配不成功，持续履行下一个分支进行判别。假如一切 case 都不匹配，那么会履行 case _分支，类似于 Java 中 default 句子。
根本语法
object TestMatchCase {
def main(args: Array[String]): Unit = {
var a: Int = 10
var b: Int = 20
var operator: Char = 'd'
var result = operator match {
case '+' => a + b
case '-' => a - b
case '*' => a * b
case '/' => a / b
case _ => "illegal"
}
println(result)
}
}
阐明：
- 假如一切 case 都不匹配，那么会履行 case _ 分支，类似于 Java 中 default 句子，若此刻没有 case _ 分支，那么会抛出 MatchError。
- 每个 case 中，不需求运用 break 句子，主动中止 case。
- match case 句子能够匹配任何类型，而不仅仅字面量。
- => 后边的代码块，直到下一个 case 句子之前的代码是作为一个全体履行，能够运用{}括起来，也能够不括。
办法护卫
假如想要表达匹配某个规模的数据，就需求在办法匹配中添加条件护卫。
代码演示：
object TestMatchGuard {
def main(args: Array[String]): Unit = {
def abs(x: Int) = x match {
case i: Int if i >= 0 => i
case j: Int if j < 0 => -j
case _ => "type illegal"
}
println(abs(-5))
}
}
办法匹配类型
匹配常量
Scala 中，办法匹配能够匹配一切的字面量，包含字符串，字符，数字，布尔值等等
代码演示：
object TestMatchVal {
def main(args: Array[String]): Unit = {
println(describe(6))
}
def describe(x: Any) = x match {
case 5 => "Int five"
case "hello" => "String hello"
case true => "Boolean true"
case '+' => "Char +"
}
}
匹配类型
需求进行类型判别时，能够运用前文所学的 isInstanceOf[T]和 asInstanceOf[T]，也可运用办法匹配完成相同的功用。
代码完成：
object TestMatchClass {
def describe(x: Any) = x match {
case i: Int => "Int"
case s: String => "String hello"
case m: List[_] => "List"
case c: Array[Int] => "Array[Int]"
case someThing => "something else " + someThing
}
def main(args: Array[String]): Unit = {
println(describe(List(1, 2, 3, 4, 5)))
println(describe(Array(1, 2, 3, 4, 5, 6)))
println(describe(Array("abc")))
}
}
匹配数组
scala 办法匹配能够对调集进行准确的匹配，例如匹配只要两个元素的、且第一个元素为 0 的数组
代码完成：
object TestMatchArray {
def main(args: Array[String]): Unit = {
for (arr <- Array(Array(0), Array(1, 0), Array(0, 1, 0),
Array(1, 1, 0), Array(1, 1, 0, 1), Array("hello", 90))) { // 对
一个数组调集进行遍历
val result = arr match {
case Array(0) => "0" //匹配 Array(0) 这个数组
case Array(x, y) => x + "," + y //匹配有两个元素的数组，然后将将元素值赋给对应的 x,y
case Array(0, _*) => "以 0 最初的数组" //匹配以 0 最初和
数组
case _ => "something else"
}
println("result = " + result)
}
}
匹配列表
办法一代码完成：
object TestMatchList {
def main(args: Array[String]): Unit = {
//list 是一个寄存 List 调集的数组
//请考虑，假如要匹配 List(88) 这样的只含有一个元素的列表,并原值回来.应该怎样写
for (list <- Array(List(0), List(1, 0), List(0, 0, 0), List(1,
0, 0), List(88))) {
val result = list match {
case List(0) => "0" //匹配 List(0)
case List(x, y) => x + "," + y //匹配有两个元素的 List
case List(0, _*) => "0 ..."
case _ => "something else"
}
println(result)
}
}
}
办法二代码完成：
object TestMatchList {
def main(args: Array[String]): Unit = {
val list: List[Int] = List(1, 2, 5, 6, 7)
list match {
case first :: second :: rest => println(first + "-" +
second + "-" + rest)
case _ => println("something else")
}
}
}
匹配元组
代码完成：
object TestMatchTuple {
def main(args: Array[String]): Unit = {
//对一个元组调集进行遍历
for (tuple <- Array((0, 1), (1, 0), (1, 1), (1, 0, 2))) {
val result = tuple match {
case (0, _) => "0 ..." //是第一个元素是 0 的元组
case (y, 0) => "" + y + "0" // 匹配后一个元素是 0 的对偶元组
case (a, b) => "" + a + " " + b
case _ => "something else" //默许
}
println(result)
}
}
}
匹配目标及样例类
代码示例：
class User(val name: String, val age: Int)
object User{
def apply(name: String, age: Int): User = new User(name, age)
def unapply(user: User): Option[(String, Int)] = {
if (user == null)
None
else
Some(user.name, user.age)
}
}
object TestMatchUnapply {
def main(args: Array[String]): Unit = {
val user: User = User("zhangsan", 11)
val result = user match {
case User("zhangsan", 11) => "yes"
case _ => "no"
}
println(result)
}
}
小结
- val user = User("zhangsan",11)，该句子在履行时，实践调用的是 User 伴生目标中的apply 办法，因而不必 new 关键字就能结构出相应的目标。
- 当将 User("zhangsan", 11)写在 case 后时[case User("zhangsan", 11) => "yes"]，会默许调用 unapply 办法(目标提取器)，user 作为 unapply 办法的参数，unapply 办法将 user 目标的 name 和 age 特点提取出来，与 User("zhangsan", 11)中的特点值进行匹配
- case 中目标的 unapply 办法(提取器)回来 Some，且一切特点均共同，才算匹配成功,特点不共同，或回来 None，则匹配失利。
- 若只提取目标的一个特点，则提取器为 unapply(obj:Obj):Option[T]，若提取目标的多个特点，则提取器为 unapply(obj:Obj):Option[(T1,T2,T3…)]，若提取目标的可变个特点，则提取器为 unapplySeq(obj:Obj):Option[Seq[T]]
函数柯里化&闭包
闭包界说：
闭包：假如一个函数,拜访到了它的外部（部分）变量的值，那么这个函数和他地点的环境,称为闭包
代码示例：
package cn.doitedu.data_export
import org.apache.commons.lang3.RandomUtils
object CloseTest {
def main(args: Array[String]): Unit = {
val fx = (a:Int,b:Int)=>{
a+b
}
val fxx = (a:Int) => {
(b:Int)=>a+b
}
val res = fxx(3)(10)
val f = () => {
var p = RandomUtils.nextInt(1,10)
val inner = () => {
p += 1
p
}
inner
}
val x1= f()
println(x1())
println(x1())
println("-----------")
val x2 = f()
println(x2())
println(x2())
println(x2())
}
}
柯里划函数的界说：
函数柯里化：把一个参数列表的多个参数,变成多个参数列表。
含义: 便利数据的演化, 后边的参数能够凭借前面的参数推演 , foldLeft的完成
有多个参数列表的函数便是柯里化函数，所谓的参数列表便是运用小括号括起来的函数参数列表
curry化最大的含义在于把多个参数的function等价转化成多个单参数function的级联，这样一切的函数就都一致了，便利做lambda演算。 在scala里，curry化对类型推演也有协助，scala的类型推演是部分的，在同一个参数列表中后边的参数不能凭借前面的参数类型进行推演，curry化今后，放在两个参数列表里，后边一个参数列表里的参数能够凭借前面一个参数列表里的参数类型进行推演。这便是为什么 foldLeft这种函数的界说都是curry的办法
慵懒加载
当函数回来值被声明为 lazy 时，函数的履行将被推延，直到咱们初次对此取值，该函数才会履行。这种函数咱们称之为慵懒函数。
代码示例：
def main(args: Array[String]): Unit = {
lazy val res = sum(10, 30)
println("----------------")
println("res=" + res)
}
def sum(n1: Int, n2: Int): Int = {
println("sum 被履行。。。")
return n1 + n2
}
运转成果：
----------------
sum 被履行。。。
res=40
留意：lazy 不能润饰 var 类型的变量
隐式转化
隐式函数
隐式转化能够在不需改任何代码的状况下，扩展某个类的功用
操练：经过隐式转化为 Int 类型添加办法。
//创立一个隐式办法，在def 前面加上关键字 implicit 让一个类型具有愈加丰厚的功用
implicit def stringWrapper(str:String)={
new MyRichString(str)
}
class MyRichString(val str:String){
def fly()={
println(str+",我是字符串，我能飞！！")
}
def jump()={
str + ":我能跳！"
}
}
package com.doit.day02
import com.doit.day01.AnythingElse.Else._
/**
* 隐式转化：说白了便是给一个函数，参数，类 赋予愈加强壮的功用
*/
object _10_隐式转化 {
def main(args: Array[String]): Unit = {
//1 自身是int 类型的，可是他却能够调用richInt这个类里边的办法
/**
* implicit def intWrapper(x: Int)= {
* //相当于创立了一个 RichInt的目标
* new runtime.RichInt(x)
* }
* 我写了一个隐式办法，传进去一个参数，回来给我的是一个目标， 并且在这个办法最前面加上了implicit 关键字 ，那么
* 这个参数的类型 就具有了该类的办法
*/
val str: String = "zss"
str.fly()
}
}
隐式参数
一般办法或许函数中的参数能够经过 implicit 关键字声明为隐式参数，调用该办法时，
就能够传入该参数，编译器会在相应的效果域寻觅契合条件的隐式值
阐明：
- 同一个效果域中，相同类型的隐式值只能有一个
- 编译器依照隐式参数的类型去寻觅对应类型的隐式值，与隐式值的称号无关。
- 隐式参数优先于默许参数
代码示例：
//界说了一个办法，办法中的参数设置的是隐式参数
def add(implicit a: Int, b: String) = {
a + b.toInt
}
//界说两个变量，前面用implicit 润饰 变成隐式的
implicit val a:Int = 10
implicit val b:String = "20"
//调用办法的时分，假如没有传参数，那么他会去上下文中找是否又隐式参数，假如有
//他就自己悄悄的传进去了，假如没有，会直接报错
add
隐式类
在 Scala2.10 后供给了隐式类，能够运用 implicit 声明类，隐式类的十分强壮，相同可
以扩展类的功用，在调集中隐式类会发挥重要的效果。
阐明：
- 其所带的结构参数有且只能有一个
- 隐式类有必要被界说在“类”或“伴生目标”或“包目标”里，即隐式类不能是尖端的。
代码示例：
implicit class snake(ant:Ant){
def eatElephant()={
println("i can eat elephant!!")
}
}
val ant: Ant = new Ant
ant.eatElephant()
隐式解析机制
- 首要会在当时代码效果域下查找隐式实体（隐式办法、隐式类、隐式目标）。
- 假如第一条规矩查找隐式实体失利，会持续在隐式参数的类型的效果域里查找。类型的效果域是指与该类型相关联的悉数伴生目标以及该类型地点包的包目标。
代码示例：
package com.chapter10
import com.chapter10.Scala05_Transform4.Teacher
//（2）假如第一条规矩查找隐式实体失利，会持续在隐式参数的类型的效果域里查找。
类型的效果域是指与该类型相关联的悉数伴生模块，
object TestTransform extends PersonTrait {
def main(args: Array[String]): Unit = {
//（1）首要会在当时代码效果域下查找隐式实体
val teacher = new Teacher()
teacher.eat()
teacher.say()
}
class Teacher {
def eat(): Unit = {
println("eat...")
}
}
}
trait PersonTrait {
}
object PersonTrait {
// 隐式类 : 类型 1 => 类型 2
implicit class Person5(user:Teacher) {
def say(): Unit = {
println("say...")
}
}
}
