Directorio de artículos
Función parcial
Las funciones parciales implementan específicamente operaciones de filtrado + en elementos de colección.
Requisitos de implementación: agregue +1 al tipo int en la lista de la colección (1,2,3,4, "abc") y agréguelo a la nueva colección, y descarte los cinco métodos de implementación para otros tipos de elementos
.
def test: Unit ={
val list =List(1,2,3,4,"abc");
//实现对 list 中int类型 进行 +1操作 并返回新的数组
//实现方式1 filter+map
println("方式1："+list.filter(f1).map(f3).map(f2));
//实现方式2 模式匹配
println("方式2："+list.map(addOne))
//以上两种方式 都不够简洁
//方式3 偏函数
//偏函数中定义两个方法 isDefinedAt 和 apply方法
//执行过程 1.遍历集合中的元素
// 2.调用parFun的isDefinedAt 方法 如果该方法返回为true 则 调用 apply方法 并将新元素添加到一个新的集合
//定义一个 偏函数 泛型表示 接受 任意类型 返回 Int类型
val parFun = new PartialFunction[Any,Int] {
override def isDefinedAt(x: Any): Boolean = {
x.isInstanceOf[Int]
}
override def apply(x: Any) = {
x.asInstanceOf[Int]+1
}
}
//对集合执行偏函数
println("方式3："+list.collect(parFun))
//偏函数简写形式
//简写成一个对象的形式
def parFun2:PartialFunction[Any,Int] = {
case in:Int =>in+1
case d:Double =>d.toInt
}
//对集合执行偏函数
println("方式4："+list.collect(parFun2))
//偏函数简写形式2
//简写成一个对象的形式
//对集合执行偏函数
println("方式5："+list.collect{
case in:Int =>in+1
case d:Double =>d.toInt
})
}
def f1(n:Any):Boolean={
n.isInstanceOf[Int]
}
def f2(n:Int):Int={
n+1
}
def f3(n:Any):Int={
n.asInstanceOf[Int]
}
def addOne(n:Any):Any={
n match{
case x:Int =>x+1
case _ =>
}
}
Nota
1) La función de mapa no admite funciones parciales, porque la capa inferior del mapa es para atravesar bucles y no puede filtrar elementos
2) La función de recopilación admite funciones parciales
Función anónima
Una función sin nombre es una función anónima, y un ejemplo de función anónima se puede establecer mediante una expresión de función
def test: Unit ={
val triple= (x:Double)=>{
3*x
}
println(triple);
println(triple(3));
}
Función de orden superior
Una función que puede aceptar una función como parámetro se denomina ejemplo de función de orden superior
def test: Unit ={
//定义test1 方法 接受两个方法f f2 和一个 double类型参数
def test1(f:Double=>Double,f2:Double=>Int,n1:Double)={
f(f2(n1))
}
def sum(d:Double):Double= d+d
def mod(d:Double):Int = d.toInt%2
println(test1(sum,mod,3))
//高阶函数可以返回一个函数
def minusxy(x:Int)={
(y:Int)=>x-y
}
//分步调用 先调用 minusxy(3) 返回一个函数f1 逻辑为 3-y 再调用 f1(4) 返回 3-4 =-1
val f1 = minusxy(3);
println(f1(4)); //-1
//一步到位调用
println(minusxy(3)(4)) //-1
print(f1)
}
Inferencia y abreviatura de parámetros
En algunos casos, se puede inferir el tipo de parámetro. Por ejemplo, se puede inferir el tipo de parámetro de función en el mapa List (1,2,3) .map (). En
este caso, se puede utilizar la abreviatura correspondiente.
1) El tipo de parámetro se puede omitir cuando se puede inferir el tipo de parámetro.2
) Los paréntesis se pueden omitir cuando la función pasada solo tiene un parámetro.3
) Si la variable aparece solo una vez en el lado derecho de =>, puede usar _ en lugar del
ejemplo
def test: Unit ={
val list = List(1,2,3,4)
println(list.map((x:Int)=>x+1))//传入一个匿名函数
println(list.map((x)=>x+1))//省略参数类型
println(list.map(x=>x+1))//只有一个参数可以省略括号
println(list.map(_+1))//参数在右侧只出现一次可以使用 _代替
println("---------------------------------")
println(list.reduce(f1))//常规函数写法
println(list.reduce((n1:Int,n2:Int)=>n1+n2))//匿名函数写法
println(list.reduce((n1,n2)=>n1+n2))
//println(list.reduce(n1,n2=>n1+n2))参数数量大于1不能省略参数括号
println(list.reduce(_+_))//参数在右侧只出现一次可以使用 _代替
}
def f1(n1:Int,n2:Int): Int ={
n1+n2
}
Cierre
Un cierre es un ejemplo general de una función y su entorno de referencia relacionado.
def minusxy(x: Int) = (y: Int) => x - y
val f = minusxy(10)
println(f(8))
Explique que
minusxy devuelve una función anónima (y: Int) => x-y, la función se refiere a la variable x fuera de la función, por lo que x y la función anónima
forman un todo asociado, es decir, un cierre.
val f = minusxy (10) La función f es un cierre, y xd = es 10 cada vez que llama a f