当前位置: 首页 > news >正文

Scala的高级用法

文章目录

  • 1. 默认参数值
    • 1.1 方法默认参数
    • 1.2 类默认参数
  • 2. 特质 (Traits)
    • 2.1 子类型
    • 2.2 扩展特征,当做接口来使用
  • 3.元组
    • 3.1 定义与取值
    • 3.2 元组用于模式匹配
    • 3.3 用于for循环
  • 4 高阶函数
    • 4.1 常见的高阶函数map
    • 4.2 简化涨薪策略代码
  • 5.嵌套方法
  • 6.多参数列表(柯里化)
  • 7.模式匹配
    • 7.1 简单的模式匹配
  • 8.隐式转换
    • 8.1 官网的列子

1. 默认参数值

1.1 方法默认参数

  def main(args: Array[String]): Unit = {//定义打印日志方法def log(date:Date,msg:String,level:String="Info"): Unit ={println(s"$date  $level $msg")}log(new Date,"你好");log(new Date(),"你好","Info");log(new Date(),"错误信息","Error");}

默认值顺序在中间的调用加上命名参数才能调用,否则报错

def log(date:Date,level:String="Info",msg:String): Unit ={println(s"$date  $level $msg")}log(new Date,msg="你好");

1.2 类默认参数

 def main(args: Array[String]): Unit = {val point1 = new Point(y = 1)point1.printLocation()}class Point(val x: Double = 0, val y: Double = 0){def printLocation(): Unit ={print(s"x=$x  $y")}}

2. 特质 (Traits)

用于在类 (Class)之间共享程序接口 (Interface)和字段 (Fields)。 它们类似于Java 8的接口。 类和对象 (Objects)可以扩展特质,但是特质不能被实例化,因此特质没有参数。

2.1 子类型

trait Animal {def say(): Unit ={println("animal say....")}def walk(): Unit ={println("animal walk....")}
}
//cat 继承animal
class Cat extends Animal{def miaomiao(): Unit ={println("car miaomiao...")}
}def main(args: Array[String]): Unit = {val cat=new Cat()cat.miaomiao()cat.walk()cat.say()
}
// car miaomiao...
//animal walk....
//animal say....

2.2 扩展特征,当做接口来使用

//定义迭代器 使用泛型Ttrait Iterator[T] {def hasNext: Booleandef next(): T}//自定义实现的Int类型的迭代器class IntIterator(to: Int) extends Iterator[Int] {private var current = 0override def hasNext: Boolean = current < tooverride def next(): Int =  {if (hasNext) {val t = currentcurrent += 1t} else 0}}def main(args: Array[String]): Unit = {val intIterator = new IntIterator(5)while(intIterator.hasNext){println(intIterator.next())}
//    0
//    1
//    2
//    3
//    4

3.元组

元组是一个可以包含不同类型元素的类,元组是不可变的。
经常用于函数返回多个值。
元组包含2-22给个元素之间。

3.1 定义与取值

 def main(args: Array[String]): Unit = {val t1 = Tuple1(1)//访问元素println(t1._1)val t2 = new Tuple1("asdas")println(t2._1)//也可以直接括号val t3=("as",12,false)//指定类型val t4=("as",12,true,0.88):Tuple4[String,Int,Boolean,Double]}

3.2 元组用于模式匹配

def main(args: Array[String]): Unit = {val courseScores = List(("Chinese", 77), ("Math", 100), ("Geo", 0 ),("English", 55 ))//遍历courseScores.foreach{ tuple => {tuple match {case p if(p._2 == 100) => println(s" ${p._1} score is 100")case p if(p._2 > 60 ) => println(s" ${p._1} score is greater than 60")case p if(p._2 == 0) => println(s" ${p._1} score is o")case _ => println(s"不及格")}}}

3.3 用于for循环

def main(args: Array[String]): Unit = {val numPairs = List((2, 5), (3, -7), (20, 56))for ((a, b) <- numPairs) {println(a * b)}///10//-21//1120}

4 高阶函数

使用函数来作为参数或则返回结果。

4.1 常见的高阶函数map

  def main(args: Array[String]): Unit = {var seqno = Seq(1,2,3)val values = seqno.map(x => x * x)for ( x <- values ){println(x )}
//    1
//    4
//    9}

4.2 简化涨薪策略代码

 //定义加薪的规则def smallPromotion(salaries: List[Double]): List[Double] =salaries.map(salary => salary * 1.2)//薪资的def greatPromotion(salaries: List[Double]): List[Double] =salaries.map(salary => salary * math.log(salary))//薪资def hugePromotion(salaries: List[Double]): List[Double] =salaries.map(salary => salary * salary)}

去掉重复代码,定义一个方法接口,涨薪的规则传入函数

  def promotion(salaries: List[Double], promotionFunction: Double => Double): List[Double] = {salaries.map(promotionFunction)}

测试

val salaries = List(2500.00,3000.00,4000.00)//实现涨薪var newsalaries= promotion(salaries,(x:Double) => x* 1.2)for(s <- newsalaries){print(s"$s ")//3000.0 3600.0 4800.0}println()println("-----------------------------")println()var newsalaries2= promotion(salaries,(x:Double) => x* x)for(s <- newsalaries2){print(s"$s ")//6250000.0 9000000.0 1.6E7 }

5.嵌套方法

嵌套方法经常使用的就是递归调用。
求阶乘

 //定义阶乘def fac(x:Int):Int = {if (x==1) {x}else {x * fac(x-1)}}//24print(fac(4))

6.多参数列表(柯里化)

方法可以定义多个参数列表,当使用较少的参数列表调用多参数列表的方法时,会产生一个新的函数,该函数接收剩余的参数列表作为其参数。这被称为柯里化

def foldLeft[B](z: B)(op: (B, A) => B): B = {var acc = zvar these: LinearSeq[A] = collwhile (!these.isEmpty) {acc = op(acc, these.head)these = these.tail}acc}

测试

 val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)val res = numbers.foldLeft(0)((m, n) => m + n)print(res) // 55

7.模式匹配

7.1 简单的模式匹配

def main(args: Array[String]): Unit = {val x: Int = Random.nextInt(5)val str = x match {case 0 => "zero"case 1 => "one"case 2 => "two"case _ => "other"}println(str)}

8.隐式转换

方法可以具有 隐式 参数列表,由参数列表开头的 implicit 关键字标记。 如果参数列表中的参数没有像往常一样传递, Scala 将查看它是否可以获得正确类型的隐式值,如果可以,则自动传递。

8.1 官网的列子

//定义一个抽象类,提供两个方法一个add 一个unitabstract class Monoid[A] {def add(x: A, y: A): Adef unit: A}//隐式实现字符串的拼接implicit val stringMonoid: Monoid[String] = new Monoid[String] {def add(x: String, y: String): String = x concat ydef unit: String = ""}//隐式实现整型的数字相加implicit val intMonoid: Monoid[Int] = new Monoid[Int] {def add(x: Int, y: Int): Int = x + ydef unit: Int = 0}//传入一个list实现不同类型的累加def sum[A](xs: List[A])(implicit m: Monoid[A]): A =if (xs.isEmpty) m.unitelse m.add(xs.head, sum(xs.tail))println(sum(List(1, 2, 3)))       // 6println(sum(List("a", "b", "c"))) //abc

完结,其他的可以到官网看看,用到在学。

http://www.lryc.cn/news/68175.html

相关文章:

  • 【31.在排序数组中查找元素的第一个和最后一个位置】
  • 如何构建“Buy Me a Coffee”DeFi dApp
  • Redis 实战篇:巧用 Bitmap 实现亿级海量数据统计
  • 3 天,入门 TAURI 并开发一个跨平台 ChatGPT 客户端
  • 14个最佳创业企业WordPress主题
  • MySQL基础(三十)PowerDesigner的使用
  • nginx 服务器总结
  • 基于Hebb学习的深度学习方法总结
  • 思科模拟器 | 访问控制列表ACL实现网段精准隔绝
  • Python os模块详解
  • Oracle PL/SQL基础语法学习13:比较运算符
  • 金仓数据库适配记录
  • ElasticSearch 学习 ==ELK== 进阶
  • 【数据结构 -- C语言】 双向带头循环链表的实现
  • 自然语言处理与其Mix-up数据增强方法报告
  • Vue(组件化编程:非单文件组件、单文件组件)
  • 【MATLAB数据处理实用案例详解(22)】——基于BP神经网络的PID参数整定
  • 第11章 项目人力资源管理
  • 07-Vue技术栈之(组件之间的通信方式)
  • 度量学习Metirc Learning和基于负例的对比学习Contrastive Learning的异同点思考
  • 3.编写油猴脚本之-helloword
  • openwrt的openclash提示【更新失败,请确认设备闪存空间足够后再试】
  • torch.nn.Module
  • 论文解析-基于 Unity3D 游戏人工智能的研究与应用
  • 6、Flutterr聊天界面网络请求
  • Java 8 腰斩!Java 17 暴涨 430%!!(文末福利)
  • 如何手写一个支持H.265的高清播放器
  • Day 1 认识软件测试——(软件测试定义、目的、原则)
  • Docker Harbor
  • 第三十四章 Unity人形动画(上)