Scala的高级用法

这篇具有很好参考价值的文章主要介绍了Scala的高级用法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

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 扩展特征,当做接口来使用

//定义迭代器 使用泛型T
  trait Iterator[T] {
    def hasNext: Boolean
    def next(): T
  }
  //自定义实现的Int类型的迭代器
  class IntIterator(to: Int) extends Iterator[Int] {
    private var current = 0
    override def hasNext: Boolean = current < to
    override def next(): Int =  {
      if (hasNext) {
        val t = current
        current += 1
        t
      } 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)
      }
    }
    //24
    print(fac(4))

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

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

def foldLeft[B](z: B)(op: (B, A) => B): B = {
    var acc = z
    var these: LinearSeq[A] = coll
    while (!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 一个unit
    abstract class Monoid[A] {
      def add(x: A, y: A): A
      def unit: A
    }
     //隐式实现字符串的拼接
      implicit val stringMonoid: Monoid[String] = new Monoid[String] {
        def add(x: String, y: String): String = x concat y
        def unit: String = ""
      }
      //隐式实现整型的数字相加
      implicit val intMonoid: Monoid[Int] = new Monoid[Int] {
        def add(x: Int, y: Int): Int = x + y
        def unit: Int = 0
      }
      //传入一个list实现不同类型的累加
      def sum[A](xs: List[A])(
        implicit m: Monoid[A]): A =
        if (xs.isEmpty) m.unit
        else m.add(xs.head, sum(xs.tail))

      println(sum(List(1, 2, 3)))       // 6
      println(sum(List("a", "b", "c"))) //abc

完结,其他的可以到官网看看,用到在学。文章来源地址https://www.toymoban.com/news/detail-461445.html

到了这里,关于Scala的高级用法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Midjourney AI绘画中文教程详解(完整版)模型、命令、参数与各种高级用法

    我有一种预感,您一下子看不完这篇内容,您得【收藏】一下,以便下次接着看~~ Midjourney AI绘画中文教程,Midjourney是一款2022年3月面世的AI绘画工具,创始人是David Holz。  只要输入想到的文字,就能通过人工智能产出相对应的图片,耗时只有大约一分钟,这个工具不仅能绘画

    2024年02月06日
    浏览(54)
  • C# 方法详解:定义、调用、参数、默认值、返回值、命名参数、方法重载全解析

    方法是一段代码,只有在调用时才会运行。 您可以将数据(称为参数)传递给方法。 方法用于执行某些操作,也被称为函数。 为什么使用方法?为了重用代码:定义一次代码,然后多次使用。 创建一个方法 方法的定义以方法的名称开头,后跟括号()。C#提供了一些预定义的

    2024年01月24日
    浏览(59)
  • Scala第六章节(类和对象的定义、访问修饰符和构造器的用法、main方法的实现形式、伴生对象的使用以及工具类的案例)

    章节目标 掌握类和对象的定义 掌握访问修饰符和构造器的用法 掌握main方法的实现形式 掌握伴生对象的使用 掌握定义工具类的案例 1. 类和对象 Scala是一种函数式的面向对象语言, 它也是支持面向对象编程思想的,也有类和对象的概念。我们依然可以基于Scala语言来开发面向

    2024年03月19日
    浏览(48)
  • Array.fill()用法

    Arrays.fill()用于快速填充数组,但是只适用于一维数组。 若是想填充二维数组则需要循环 详细用法: Arrays.fill(int[] a, from, to, int var) int[] a: 需要填充的数组。 from:数组填充的起始位置(包括此位置)。 to: 数组填充的终止位置(不包括此位置)。 int var: 填充进数组的值。 若无

    2024年02月12日
    浏览(48)
  • Array.from() 超全用法详解

    Array.from 方法用于将两类对象转为真正的数组:类似数组的对象(array-like object)和可遍历(iterable)的对象(包括 ES6 新增的数据结构 Set 和 Map)。 下面是一个类似数组的对象, Array.from 将它转为真正的数组。 实际应用中,常见的类似数组的对象是 DOM 操作返回的 NodeList 集合

    2024年02月04日
    浏览(39)
  • Numpy || np.array()函数用法指南

    numpy ndarray对象是一个n维数组对象,ndarray只能存储一系列相同元素。 numpy.array()使用说明:object是必须输入的参数,其余为可选参数。 创建存储元素类型不同的数组: 创建生成器: 当输入的object元素有不同类型时,将保留存储空间最大的类型: 当多维数组元素个数不一致时:

    2024年01月24日
    浏览(52)
  • Python cv.StereoSGBM_create方法参数与用法详解

    创建StereoSGBM(semi-global block matching)对象。该对象实现了半全局匹配算法。 cv.StereoSGBM_create([, minDisparity[, numDisparities[, blockSize[, P1[, P2[, disp12MaxDiff[, preFilterCap[, uniquenessRatio[, speckleWindowSize[, speckleRange[, mode]]]]]]]]]]]) - retval minDisparity:最小可能的差异值。正常情况下,它为零,但

    2024年02月05日
    浏览(54)
  • Scala面向对象编程(高级部分)

    (1)回顾Java中的静态概念 public static 返回值类型 方法名(参数列表) {方法体} 静态属性… 说明: Java中静态方法并不是通过对象调用的,而是通过类对象调用的,所以静态操作并不是面向对象的。 (2)Scala中静态的概念-伴生对象 ①Scala语言是完全面向对象(万物皆对象)的语言

    2024年02月09日
    浏览(52)
  • Scala集合常用函数 - 高级计算函数

    水善利万物而不争,处众人之所恶,故几于道💦   1. 过滤 - filter   2. 转换/映射 - map   3. 扁平化 - flatten   4. 扁平化+映射 - flatMap   5. 分组 - groupBy   6. 简化(规约) - reduce   7. 折叠 - fold   8. 函数小练习 1. 过滤 - filter  遍历一个集合并从中获取满足指定

    2024年02月17日
    浏览(44)
  • Scala中的Either的用法

    在 Scala 中,Either 是一种表示两种可能值的数据类型。它可以用来处理函数可能返回的两种不同类型的结果,通常用于错误处理或者结果分支情况。Either 有两个子类:Left 和 Right,其中 Left 通常用于表示错误或异常情况,而 Right 用于表示正常的结果 下面是一个使用 Either 模拟

    2024年02月12日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包