Scala的高级特性
☀小白的Scala学习笔记
目录
[4）练习 Tea](#4）练习 Tea)
1.匿名函数
Scala 中的匿名函数是一种没有命名的函数，通常用于在代码中定义和传递简单的功能逻辑。匿名函数在 Scala 中被称为函数字面量（function literals），它的语法非常简洁和灵活。
下面是一个简单的 Scala 匿名函数的例子：
Scala
// 定义一个接受两个整数参数并返回它们之和的普通函数
def add(x: Int, y: Int): Int = x + y
// 使用匿名函数实现相同的功能
val addFunction = (x: Int, y: Int) => x + y
// 在调用时，可以直接传递参数并调用匿名函数
val result = addFunction(3, 5)
println(result) // 输出: 8
在这个例子中，我们通过 val addFunction = (x: Int, y: Int) => x + y 的方式定义了一个匿名函数，它接受两个整数参数 x 和 y，并返回它们的和。在调用时，我们直接使用 addFunction(3, 5) 进行调用，并将结果打印出来。
匿名函数在 Scala 中非常常见，特别是在函数式编程中经常用于传递逻辑给高阶函数（higher-order functions）或者在需要临时定义函数的场景下使用。它的灵活性和简洁性使得代码更加清晰和易于理解。
2.如何把方法转化为函数
在 Scala 中，可以使用 _操作符来将方法转换为函数。
注：下划线前有空格
Scala
package com.oracle.jtxy
object Test2 {
// 定义一个普通的方法
def greet(name: String): String = {
s"Hello, $name!"
}
def main(args: Array[String]): Unit = {
// 使用下划线将方法转化为函数
val greetFunction = greet _
// 调用函数
val result = greetFunction("Alice")
println(result) // 输出: Hello, Alice!
}
}
Scala
package com.oracle.jtxy
object Test3 {
// 定义一个普通的方法
def double(x: Int): Int = x * 2
def main(args: Array[String]): Unit = {
// 使用`_`操作符将方法转化为函数
val doubleFunction = double _
// 调用函数
val result = doubleFunction(5)
println(result) // 输出: 10
}
}
3.柯里化
1）柯里化
柯里化：在传递参数时可以分为多个括号来传递
Scala
package com.oracle.jtxy
object Test1 {
def add(a:Int)(b:Int)=a+b
def main(args: Array[String]): Unit = {
//柯里化：在传递参数时可以分为多个括号来传递
val i = add(12)(24)
println(i)
}
}
那么 我们可能会说它有些多余 不过后面我们很快就能见到它的效果啦
2）实例
假设现在我们有一个方法 求 a+b 但是我现在想要在调用时 只传入一个参数 a
b 给一个默认值 变成隐式参数
Scala
package com.oracle.jtxy
object Test1 {
implicit val c:Int=3
def add(a:Int)(implicit b:Int)={
a+b
}
//b给一个默认值 调用的时候不需要传递 把参数变成隐式参数
//当我们使用柯里化后 如果有参数是隐式的话 Scala会自动在上下文中搜索对应类型的变量
def main(args: Array[String]): Unit = {
//柯里化：在传递参数时可以分为多个括号来传递
val i = add(12)
println(i)
}
}
3）柯里化应用：排序
1.通过隐式变量实现（Ordering）
Scala
package com.oracle.jtxy
object Test4 {
//ord 对象 能指导两个变量的大小
//通过隐式变量实现
implicit val ord=new Ordering[Stu](){
override def compare(x: Stu, y: Stu): Int = x.sage - y.sage
}
case class Stu(sname:String,ssex:String,sage:Int)
def main(args: Array[String]): Unit = {
val list=List(Stu("zhangsan1","nan",21),Stu("zhangsan2","nan",11),Stu("zhangsan3","nan",16),Stu("zhangsan4","nan",33))
val res=list.sortBy(x=>x)
println(res)
}
}
2.通过隐式转换实现（Ordered）
Scala
package com.oracle.jtxy
object Test4 {
//隐式转换 定义的是隐式的方法
implicit def toStu(s:Stu)=new Ordered[Stu]{
override def compare(that: Stu): Int = s.sage - that.sage
}
case class Stu(sname:String,ssex:String,sage:Int)
def main(args: Array[String]): Unit = {
val list=List(Stu("zhangsan1","nan",21),Stu("zhangsan2","nan",11),Stu("zhangsan3","nan",16),Stu("zhangsan4","nan",33))
val res=list.sortBy(x=>x)
println(res)
}
}
4）练习 Tea
1.通过隐式变量实现
Scala
package com.oracle.jtxy
import scala.collection.mutable.ArrayBuffer
object Test5 {
//通过隐式变量实现
implicit val ord=new Ordering[Tea](){
override def compare(x: Tea, y: Tea): Int = x.tage - y.tage
}
case class Tea(tname:String,tsex:String,tage:Int)//样例类
def main(args: Array[String]): Unit = {
val array=new ArrayBuffer[Tea]()
array.append(Tea("wangwu","nan",23),Tea("lisi","nv",45),Tea("maliu","nan",65),Tea("mazi","nan",28))
val teas = array.sortBy(x => x)
println(teas)
}
}
2.通过隐式转换实现
Scala
package com.oracle.jtxy
import scala.collection.mutable.ArrayBuffer
object Test5 {
//通过隐式变量实现
implicit def toTea(t:Tea)=new Ordered[Tea]{
override def compare(that: Tea): Int = t.tage - that.tage
}
case class Tea(tname:String,tsex:String,tage:Int)//样例类
def main(args: Array[String]): Unit = {
val array=new ArrayBuffer[Tea]()
array.append(Tea("wangwu","nan",23),Tea("lisi","nv",45),Tea("maliu","nan",65),Tea("mazi","nan",28))
val teas = array.sortBy(x => x)
println(teas)
}
}