scala高阶

最新推荐文章于 2022-03-08 10:37:53 发布
最新推荐文章于 2022-03-08 10:37:53 发布
阅读量139 收藏
点赞数
分类专栏： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43457608/article/details/109392516
版权

Scala高级特性

1.课程目标

  • 深入理解高阶函数 闭包函数 柯里化函数
  • 深入理解隐式方法 隐式变量以及隐式参数
  • 综合案例 模拟Spark任务调度

2.Scala中函数

2.1高阶函数
  • 函数是一个对象，如果一个方法的参数包含函数对象，那么这个方法就叫做高阶函数或者高阶方法

格式：
	def 方法名称（（输入数据）=>{输出数据}）：返回值类型={
        方法体
    }


/**
  * 函数是一个对象，如果一个方法的参数包含函数对象，那么这个方法就叫做高阶函数或者高阶方法
  *
  * 格式：
  * def 方法名称（（输入数据）=>{输出数据}）：返回值类型={
  * 方法体
  * }
  */
class Number(val x: Int) {
  //高阶函数
  def compute(f: Int => Int): Int = {
    f(x)
  }

  def square(x: Int): Int = {
    x * x
  }
}


object Scala_01_gaojie {
  def main(args: Array[String]): Unit = {
    val number = new Number(10)
    //求平方
    val f: Int => Int = (x: Int) => x * x

    println(number.compute(f)) //方法的功能依赖于函数参数

    //求立方
    val f2: Int => Int = (x: Int) => x * x * x
    println(number compute f2)
  }
}


  • /**
  * ShopCar 类
  * 数组 Arrybuffer[Double] 装商品
  * 方法 add 添加商品价格功能
  * 方法：计算总价 （参数：函数 功能实现打折）
  */
class ShopCar {
  val goods = ArrayBuffer[Double]()
  def add(g: Double): Unit = {
    goods += g
  }

  //结算
  def account(f: Double => Double): Double = {
    //1.计算所有商品的总价
    var sum: Double = 0.0
    goods.foreach((x: Double) => sum = sum + x)
    //2.通过函数进行打折
    f(sum)
  }
}


object Scala_02_gaojie {
  def main(args: Array[String]): Unit = {
    val car = new ShopCar
    car add 10
    car add 50
    car add 88.88

    //打折 满100 减50 满80 减20
    val f: Double => Double = (sum: Double) => {
      if (sum >= 100) {
        sum - 50
      } else if (sum >= 80) {
        sum - 20
      } else {
        sum
      }
    }
   val result=car account f
    println(s"消费：$result")

  }
}
2.2高阶函数使用规则

  • 以Array.foreach 为例 说明函数的使用规则

  • object Scala_03_gaojie {
  def main(args: Array[String]): Unit = {
    val arr = Array[Int](1, 4, 5, 8, 9)
    //第一种遍历方式
    val f = (x: Int) => println(x)
    arr.foreach(f)
    println("--------------")
    //第二种方式 使用匿名函数
    arr.foreach((x: Int) => println(x))
    println("--------------")
    //第三种方式 省略数据类型 匿名函数
    arr.foreach( x=>println(x))
    println("-----------------")
    //第四中方式  _ 占位符
    arr.foreach(println(_))
    println("-----------------")
    //第五中方式 省略占位符 省略小括号
    arr.foreach(println)
    println("-----------------")
    //map操作省略形式
    arr.map(_*2).foreach(println) 
    println("-----------------")
  //  arr.map(x=>x*2)
    arr.filter(_%2==0).foreach(println)

    //reduce 操作

    println(arr.reduce(_+_))  //arr.reduce((x:Int,y:Int)=>x+y)
  }
}
2.3闭包函数
  • 一个函数如果使用了外部变量，则这个函数就叫做闭包函数
val a=10000
val f:Int=> Int =(x:Int)=>a+x  //方法内部，主要用来减少函数参数传递的
val f2:(Int,Int)=>Int =(x:Int,y:Int)=x+y
闭包函数：减少函数参数列表，使得函数操作相对更为简单
2.4柯里化函数
  • 概念：将一个具有复杂（多个）参数列表的方法转换成具有（多个简单参数列表）的方法，这个过程就叫做柯里化过程 ，具有多个简单参数列表的方法 ，就叫做柯里化方法
柯里化函数： 柯里化函数是函数的级联操作
柯里化函数实际上将每一步操作都返回一个function，也就说柯里化是将函数作为了方法的返回值

def add(x:Int,y:Int)=x+y //正常方法
def add(x:Int)(y:Int)=x+y  //柯里化方法
class Number2(val x: Int) {
  //高阶函数
  def compute(f: Int => Int): Int = {
    f(x)
  }
}

object Scala_05_currying {
  def add(x: Int, y: Int) = x + y //正常方法
  /**
    * 如果一个方法具备多个参数列表，则可以分步骤进行操作
    * 如果参数是准备不完整的，我们可就通过柯里化进行延迟操作
    *
    * @param x
    * @param y
    * @return
    */
  def add2(x: Int)(y: Int) = x + y //柯里化方法

  def add3(x: Int)(y: Int)(z: Int) = x + y + z

  def add4(x:Int) = (y:Int)=>x+y

  def main(args: Array[String]): Unit = {
    println(add(1, 2))
    println(add2(1)(2))
    //柯里化方法分步操作
    val f = add2(1) _ //返回值是函数 function1
    println(f.toString())
    val result = f(2)
    println(result)
    println("-------------------")

    val number = new Number2(2)

    println(number.compute(f))

    println("-------------------")

    //add3 分步骤操作
    val f3=add3(1) _ //function1
    println(f3.toString())
    val f4=f3(2) // function1
    println(f4)
    val result2=f4(3)  //6
    println(result2)

    //柯里化函数： 柯里化函数是函数的级联操作
    val f5=add4(1)(2)  //function1
  }
}
2.5柯里化应用场景
  • 统计就业率
公式：已工作人数/班级人数
定义：
	def workRate(worker:Int,sum:Int)=worker.toDouble/sum.toDouble
	def workRate2(sum:Int)(worker:Int)=worker.toDouble/sum.toDouble

object Scala_06_currying {
  def workRate(worker: Int, sum: Int) = worker.toDouble / sum.toDouble

  def workRate2(sum: Int)(worker: Int) = worker.toDouble / sum.toDouble
  def workRate2(worker: Int)(implicit sum: Int) = worker.toDouble / sum.toDouble

  def main(args: Array[String]): Unit = {
    //需求 多次统计 7, 10 ，15 ，30，90  班级人数 100
    // 就业人数：50  80  90 98 100
    println( workRate(50,100))
    println( workRate(80,100))
    println( workRate(90,100))
    println( workRate(98,100))
    println( workRate(100,100))

    println("---------------------------------")
    //使用柯里化方法 规避掉冗余数据
    val f=workRate2(100) _
    println(f(50))
    println(f(80))
    println(f(90))
    println(f(98))
    println(f(100))
  }
}
柯里化函数能够减少方法参数的传递

3. 隐式转换操作

  • 格式： 能够将源数据类型转换成目标数据类型
	implicit def 名称(源数据类型) =目标类型对象
注意：隐式转换方法只能存在于object中

class Dog {
  def run(): Unit = {
    println("飞奔吧小狗")
  }
}

class Teacher {
  def readScala(): Unit = {
    println("教学scala")
  }
}

class Bird {
  def fly(): Unit = {
    println("飞上天")
  }
}

object Scala_07_implicit {
  //implict def 名称(源数据类型) =目标类型对象
  implicit def dogToTeacher(d: Dog) = new Teacher

  //让狗飞上天
  implicit def dogToBird(d: Dog) = new Bird

  def main(args: Array[String]): Unit = {
    val dog = new Dog
    dog.run()
    dog.readScala()
    dog.fly()
  }
}
3.1 隐式转换的对象类型
  • 总结:
	1.隐式转换方法可以将一个对象转换成函数对象
	2.隐式转换方法可以将一个对象转换成单例对象Object
	3.具有继承关系的子类可以继承父类的隐式转换功能
import java.io.File

import scala.io.Source

class Person

class Sun extends Person

object Scala_08_implicit {
  //person能否通过隐式转换将函数
  implicit def personToFunction(p: Person) = (x: Int) => x * x

  //person对象能否转换成object对象呢 Source
  implicit def personToSource(p: Person) = Source

  def main(args: Array[String]): Unit = {
    val person = new Person
    println(person(10))
    println(person.fromFile(new File("D:/a.txt")).getLines().mkString(","))
    val sun = new Sun
    println(sun(100)) //10000
    println(sun.fromFile(new File("D:/a.txt")).getLines().mkString(","))
  }
}
3.2隐式参数和隐式变量
  • 隐式变量：
	implicit val/var 变量名称=值
隐式参数 ：修饰参数列表 implicit只能用在参数列表的最前边
	def 方法名称(implicit 参数列表)
总结：隐式变量可以给隐式参数提供默认参数。方法保留原始功能
object Scala_09_implicit {

  //implicit val/var 变量名称=值
  implicit val a: Int = 100
  implicit val b: Long = 1000
  //implicit val c: Int = 80
  //def 方法名称(implicit 参数列表)
  def run(implicit speed: Int, time: Long): Unit = {
    println(s"以${speed}跑 时间${time}")
  }

  def main(args: Array[String]): Unit = {
    run
    run(90,9000)
  }
}
3.3 隐式转换的管理
  • 一般情况，会将所有的隐式转换操作 都放在统一object中， 使用时需要进行导入
import object._ //代表导入所有
import object.名称 //名称可以是方法名称也可以是变量名称


object CommonImplicitObject {
  //implict def 名称(源数据类型) =目标类型对象
  implicit def dogToTeacher(d: Dog) = new Teacher

  //让狗飞上天
  implicit def dogToBird(d: Dog) = new Bird

  //implicit val/var 变量名称=值
  implicit val a: Int = 100
  implicit val b: Long = 1000
  implicit val c: Int = 80
}
3.4隐式转换的查找机制
  • 查找机制：
	1.在当前隐式转换操作的文件或者object中进行查找
	2.他在源数据类型的伴生对象中进行查找

class Person10 {
  def say() = println("说话")
}

class Dog10 {

}

object Dog10 {
  implicit def dogToPerson(d: Dog10) = new Person10
}

object Scala_10_implicit {

  def main(args: Array[String]): Unit = {
    val dog1 = new Dog10
    dog1.say()
  }
}

4.编程实战

  • 小目标：实现基于akka的spark底层通信机制

    • Spark

      • spark是基于内存的分布式大数据处理框架。主/多从

    • akka

      • akka是基于scala 开发的轻量级RPC通信框架 。高可用、高性能、可扩展。

    • akka编程模型Actor

      • 可以发送和接受消息
      • 多个actor可以并发执行
      • akka中actor能够创建和管理其他的actor
      • actor轻量级的编程模型，1GB=百万级的actor，支持高并发。

    • akka的两个核心编程类

      • ActorSystem
        • ActorSystem创建并且管理所有Actor，并且可以发送消息。在一个进程ActorSystem是单例存在的
      • Actor
        • preStart：在actor初始化(调用构造函数)完成之后直接调用的方法。做一些初始化工作逻辑，还有启动定时任务操作。该方法在整个actor声明周期只调用一次
        • receiver：接受消息并且根据消息进行相应的逻辑处理的。receiver可以循环接受消息

      想要基于akka的编程，首先创建的ActorSystem对象，要想基于akka的逻辑处理就必须创建actor。这里actor是有ActorSystem创建和管理的

  • 基于akka的两台终端进行互相通信

  • master代码实现

    • package cn.itcast

import akka.actor.{Actor, ActorSystem, Props}
import com.typesafe.config.{Config, ConfigFactory}

/**
  * 定义actor类
  */
class Master extends Actor {
  override def receive: Receive = {
    case "test" => println("测试成功")
    case "slaver_regist" => {
      sender ! "SUC"
    }
  }
}

object Master {
  def main(args: Array[String]): Unit = {
    val host = "192.168.41.41"   //IP地址要修改成你们本机IP地址
    val port = 8888
    val configStr =
      s"""
         |akka.actor.provider="akka.remote.RemoteActorRefProvider"
         |akka.remote.netty.tcp.hostname="$host"
         |akka.remote.netty.tcp.port="$port"
      """.stripMargin
    val config = ConfigFactory.parseString(configStr)
    //创建actorSystem对象
    val masterActorSystem = ActorSystem.apply("masterActorSystem", config)
    //创建actor 自动启动actor
    val masterActor = masterActorSystem.actorOf(Props(new Master), "masterActor")
    masterActor ! "test"

    //akka.tcp://masterActorSystem@192.168.41.41:8888 在该链接之下，ActorSystem管理所有的acotr
    //也就是说 如果我们想要在其他进程中获取masterActor，则必须通过协议接口

  }
}

  • slaver代码实现

    • package cn.itcast

import akka.actor.{Actor, ActorSystem, Props}
import com.typesafe.config.ConfigFactory

class Slaver extends Actor {
  //创建完成后向master发送消息
  override def preStart(): Unit = {
    //需要获取masterAcotr对象
    val masterActor = context.actorSelection("akka.tcp://masterActorSystem@192.168.41.41:8888/user/masterActor")
    masterActor ! "slaver_regist"
  }

  override def receive: Receive = {
    case "slaver_test" => println("slaver_test 测试成功")
    case "SUC" => println("注册成功")
  }
}

object Slaver {
  def main(args: Array[String]): Unit = {
    val host = "192.168.41.41"  //IP地址要修改成你们本机IP地址
    val port = 9999
    val configStr =
      s"""
         |akka.actor.provider="akka.remote.RemoteActorRefProvider"
         |akka.remote.netty.tcp.hostname="$host"
         |akka.remote.netty.tcp.port="$port"
      """.stripMargin
    val config = ConfigFactory.parseString(configStr)
    //创建ActorSystem
    val slaverActorSystem = ActorSystem.apply("slaverActorSystem", config)
    //创建actor
    val slaverActor = slaverActorSystem.actorOf(Props(new Slaver), "slaverActor")
    slaverActor ! "slaver_test"
  }
}
4.1 基于akka模拟实现spark的通信机制

  • 业务场景

    • master端：负责接收worker端的注册，并且管理worker。在管理过程总，能够自动检测worker状态，查看worker是否超时。如果worker超时则直接剔除掉，接受worker的心跳信息，并且更新worker状态
    • worker端：负责向master注册，并且提交其资源信息（cpu和内存），worker需要实时的向master发送心跳信息。

  • 分析业务模型：结合样例类和样例对象

    • 样例对象 CheckTimeOut
    • 样例类 Registed（msg：String） master反馈给worker信息
    • 样例类 WorkerRegist（workInto:WorkInfo） worker向master注册的信息
    • 类：WorkInfo（包含了worker资源信息（cpu和内存，workerId）） 资源对象
    • 样例对象 HeartBeat worker内部定时任务的标志
    • 样例类 HeartBeatMsg（workerId:String） 向master发送的心跳信息

  • 实现

    • master实现

    • package cn.itcast.master

import akka.actor.{Actor, ActorSystem, Props}
import cn.itcast.common._
import com.typesafe.config.ConfigFactory

import scala.collection.mutable
import scala.concurrent.duration._

class Master extends Actor {
  val interval_time = 3000
  //master用来管理woker信息的
  val workerMap = mutable.Map[String, WorkInfo]()

  val TIME_OUT = 5000 //超时时长

  override def preStart(): Unit = {
    //actor启动立即启动定时任务
    //定时任务定义
    import context.dispatcher
    //四个参数：
    // 1.延迟多长时间开始启动 定时任务
    //2. 间隔多长时间执行一次定时任务
    //3. Actor对象
    //4. 消息
    context.system.scheduler.schedule(0 millis, interval_time millis, self, CheckTimeOut)
  }

  override def receive: Receive = {
    case CheckTimeOut => {
      //检查worker的状态，worker是否超时
      for (t <- workerMap) {
        val workInfo = t._2
        if (System.currentTimeMillis() - workInfo.WORK_STATE > TIME_OUT) {
          workerMap -= t._1
        }
      }
      println("------------存活的worker信息---------------------")
      //打印存活的worker信息
      workerMap.foreach(t => println(t._2.toString))
    }
    //处理worker的注册
    case WorkerRegist(workInfo) => {
      //判断worker是否已经注册
      if (!workerMap.contains(workInfo.workerId)) {
        workInfo.WORK_STATE = System.currentTimeMillis() //直接更新状态
        workerMap += (workInfo.workerId -> workInfo) //注册成功了
        sender ! Registed("SUC")
      }
    }
    //接受worker端的心跳信息
    case HeartBeatMsg(workId) => {
      //更新worker的状态
      val workInfo: WorkInfo = workerMap.get(workId).get
      workInfo.WORK_STATE = System.currentTimeMillis()
    }
  }
}


object Master {
  def main(args: Array[String]): Unit = {
    val host = "192.168.41.41"
    val port = 8888
    val cfgStr =
      s"""
         |akka.actor.provider="akka.remote.RemoteActorRefProvider"
         |akka.remote.netty.tcp.hostname="$host"
         |akka.remote.netty.tcp.port="$port"
      """.stripMargin
    val config = ConfigFactory.parseString(cfgStr)
    //创建ActorSytem Actor对象
    val masterActorSystem = ActorSystem.apply("masterActorSystem", config)
    //创建Actor对象
    val masterActor = masterActorSystem.actorOf(Props(new Master), "masterActor")
  }
}

    • worker端实现

      • package cn.itcast.worker

import java.util.UUID

import akka.actor.{Actor, ActorSelection, ActorSystem, Props}
import cn.itcast.common._
import cn.itcast.master.Master
import com.typesafe.config.ConfigFactory

import scala.concurrent.duration._

class Worker extends Actor {
  //workerID
  val wid = UUID.randomUUID().toString
  val cpu = 24 + (math.random * 100).toInt
  val memory = 32 + (math.random * 100).toInt
  var masterActor: ActorSelection = _

  //向master进行注册
  override def preStart(): Unit = {
    val workInfo = new WorkInfo(wid, cpu, memory)
    //获取masteractor 发送消息
    masterActor = context.actorSelection("akka.tcp://masterActorSystem@192.168.41.41:8888/user/masterActor")
    masterActor ! WorkerRegist(workInfo)
  }


  override def receive: Receive = {
    //worker端接受到master的反馈信息
    case Registed(msg) => {
      println("注册成功")
      //启动定时任务
      import context.dispatcher
      context.system.scheduler.schedule(0 millis, 3000 millis, self, HeartBeat)
    }
    //接受心跳信息HeartBeat
    case HeartBeat => {
      //给master发送心跳信息
      masterActor ! HeartBeatMsg(wid)
    }

  }
}

object Worker {
  def main(args: Array[String]): Unit = {
    //构建ActorSystem Actor对象
    val host = "192.168.41.41"
    val port = 9999
    val cfgStr =
      s"""
         |akka.actor.provider="akka.remote.RemoteActorRefProvider"
         |akka.remote.netty.tcp.hostname="$host"
         |akka.remote.netty.tcp.port="$port"
      """.stripMargin
    val config = ConfigFactory.parseString(cfgStr)
    //创建ActorSytem Actor对象
    val workerActorSystem = ActorSystem.apply("workerActorSystem", config)
    //创建Actor对象
    val workerActor = workerActorSystem.actorOf(Props(new Worker), "workerActor")
  }
}

      • 对象

        • package cn.itcast.common

/**
  * - 样例对象 CheckTimeOut
  * - 样例类 Registed（msg：String）  master反馈给worker信息
  * - 样例类 WorkerRegist（workInto:WorkInfo） worker向master注册的信息
  * - 类：WorkInfo（包含了worker资源信息（cpu和内存，workerId）） 资源对象
  * - 样例对象 HeartBeat    worker内部定时任务的标志
  * - 样例类 HeartBeatMsg（workerId:String）  向master发送的心跳信息
  */
class BaseMsg extends  Serializable
//样例对象 CheckTimeOut
case object CheckTimeOut

//样例类 Registed（msg：String）
case class Registed(msg: String) extends  BaseMsg

//类：WorkInfo
class WorkInfo(val workerId: String, cpu: Int, memory: Int) extends  BaseMsg{
  var WORK_STATE: Long = 0 //保存worker状态信息

  override def toString: String = {
    "workerInfo:" + workerId + "\t" + cpu + "\t" + memory
  }
}

//样例类 WorkerRegist（workInto:WorkInfo）
case class WorkerRegist(workInto: WorkInfo) extends BaseMsg

//HeartBeat 样例对象
case object HeartBeat

//样例类 HeartBeatMsg（workerId:String）向master发送的心跳信息

case class HeartBeatMsg(workId: String) extends BaseMsg

​

半度、
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数据必学语言Scala（三十七）：scala高级用法 高阶函数用法
Lansonli（蓝深李）的博客
05-14 1476
目录 高阶函数用法 作为值的函数 匿名函数 柯里化（多参数列表） 闭包 高阶函数用法 Scala 混合了面向对象和函数式的特性，在函数式编程语言中，函数是“头等公民”，它和Int、String、Class等其他类型处于同等的地位，可以像其他任何数据类型一样被传递和操作。 高阶函数包含：作为值的函数、匿名函数、闭包、柯里化等等。 作为值的函数 在scala中，函数就像和数字、字符串一样，可以将函数传递给一个方法。我们可以对算法进行封装，然后将具体的动作传递给算法，这种特性很有用。 .
scala编程第16章学习笔记（3）——List类的高阶方法
weixin_34372728的博客
11-17 118
列表间映射：map、flatMap和foreach 1.xs map f 操作返回把函数f应用在xs的每个列表元素之后由此组成的新列表。如： scala&gt; List(1, 2, 3) map (_ + 1) res0: List[Int] = List(2, 3, 4) scala&gt; val words = List("the", "quick", "brown", "...
Scala的进阶（高阶函数、集合、泛型、异常...）
MCY的博客
01-08 317
匿名函数 参数列表 => 函数体 柯里化函数（Curring） 柯里化函数指将接受多个参数的函数，改造为接受单个参数的函数并且返回一个函数对象的过程就称为柯里化 目的是让函数通用性更高（传如一个参数，任意拆分函数，返回值是函数对象） // 函数原始写法 def sum(x:Int,y:Int):Int = x + y // 柯里化函数的标准写法 def sum2(x:I...
Scala知识点21---高阶方法
别人笑我太疯癫，我笑他人看不穿。
01-21 235
Scala有一个当初差点挤掉JAVA地位的东西，就是高阶方法，也叫高阶函数
scala入门2-方法、函数、高阶函数
瑞瑞的博客
11-18 141
基于Java学习scala 1、方法 def method1(x:Int,y:Int):Int={x+y} def 方法名(变量名:变量类型,...):返回值类型={方法体} scala方法可以定义在方法中 方法如果定义在类中是可以重载的 方法如果定义在方法中是不可以重载的 2、方法简化原则 1)方法体只有一行，{}可以省略 2)返回值类型为Unit，=可以省略 3)方法体的最后一行作为返回值类型，则返回值类型可以省略 4)方法不需要参数，()可以省略 注意： 1和2，不能同时
Scala-Unit-1-概述及安装
SHZHJ2000的博客
01-05 132
一、Scala简介 官网：www.scala-lang.org Scala语言很强大，它集成了面对对象和函数式编程的特点，并且运行在JVM(Java Virtual Machine)上，即必须安装jdk。 问题：学习大数据为什么Scala语言？ 　　因为大数据的一个重要组件：spark是用Scala语言编写的 　　用python写spark　 ->　　good 　　...
[Scala基础]--Null、null、 Nothing、 Nil、 None和Unit
欢迎来到我的博客，一起探索代码里的世界！
12-19 8952
原文：http://oldfashionedsoftware.com/2008/08/20/a-post-about-nothing/您听到的有关Scala语言的主要抱怨之一是与Java相比，它太复杂了。一般的开发者永远无法对类型系统，函数式编程语言等有足够的理解。这就是论点。为了支持这个位置，你会经常听到它指出Scala包含了一些虚无的概念（Null，null，Nil，Nothing，None和...
Scala入门学习
Kuicer的博客
02-25 386
求区间和、平方和、立方和函数 def sum(a: Int, b: Int) = (a + b) * (b - a + 1) / 2 def cal2(a: Int) = a * (a + 1) * (2 * a + 1) / 6 def sum2(a: Int, b: Int) = cal2(b) - cal2(a - 1) def sum3(a: Int, b: Int) = sum(a, b) * sum(a, b) 求GCD def GCD(a: Int, b: Int): Int = {
scala基础练习
鸭梨的博客
11-15 1442
1、在Scala REPL中，计算3的平方根,然后再对该值求平方。现在，这个结果与3相差多少？ scala> math.sqrt(3) res14: Double = 1.7320508075688772 scala> math.pow(res14,2) res15: Double = 2.9999999999999996 scala> 3-res15 res16: Double = 4.440892098500626E-16 2、如何检测一个变量是val还是var? val不能重
scala常用函数大全
qq_41704237的博客
08-02 1676
一、添加、更新元素函数 ++ 两个集合相加，返回一个左边集合类型的新集合 val a = Array(1, 2) val b = Array(3, 4) val c = a ++ b println(c.mkString(",")) // 1,2,3,4 ++：两个集合相加，返回一个右边集合类型的新集合 val a = List(1, 2) val b = scala.collection.mutable.LinkedList(3, 4) val c = a ++:
水仙花数是指其个位、十位、百位3个数的立方和等于这个数本身，请用Scala编程求出100～999之间的所有水仙花数。
qq_45894761的博客
03-08 3436
package com.scalaDemo object code02 { def main(args: Array[String]): Unit = { for(i <- 100 to 999) { val a = i / 100 val b = (i / 10) % 10 val c = i % 10 if (a*a*a + b*b*b + c*c*c == i){ println(i) } } .
三次方的研究
08-01 1321
求解如下的多项式方程：8x+4−−−−−√3−8x−4−−−−−√3=2 \sqrt[3]{8x+4}-\sqrt[3]{8x-4}=2 三次方根 ⇒ 三次方，所以令 a=8x+4−−−−−√3,b=8x−4−−−−−√3a=\sqrt[3]{8x+4},b=\sqrt[3]{8x-4}，得如下的联立方程：{a−b=2a3−b3=8 \left\{ \begin{array}{l} a-b=2\\
scala怎么做幂运算_Scala幂（幂）函数示例
cumtb2002的博客
06-29 5693
scala怎么做幂运算Scala programming language has a huge set of libraries to support different functionalities. Scala编程语言具有大量的库来支持不同的功能。 scala.math.pow() (scala.math.pow()) The pow() function is used for t...
Scala 进行算数运算
abcdefghwelcome的博客
12-29 2058
聚合函数 1. 先创建一个集合 2. 求和 3.最大值 4.最小值 5. 相加 5.2 a.fold  //聚合时要将初始值累加进去 5.3 a.par.fold（10） //并行执行(并行化），初始值每个线程都加10，每次运行结果不一样 5.4  左加 5.5  右加 6.迭代 a.reduce(_+_) 第一个_是初始值，或者为1+2=...
scala中各种符号的意思
热门推荐
干货
04-08 1万+
1. 泛型限定 泛型中的符号 &lt;: &gt;: &lt;% : + - 符号 作用 [T &lt;: UpperBound] 上界 [T &gt;: LowerBound] 下界 [T &lt;% ViewBound] 视界 [T : ContextBound] 上下文界 [+T] 协变...
Scala的高级特性
weixin_30885111的博客
07-18 85
高阶函数 概念 Scala混合了面向对象和函数式的特性，我们通常将可以作为参数传递到方法中的表达式叫做函数。在函数式编程语言中，函数是“头等公民”，高阶函数包含：作为值的函数、匿名函数、闭包、柯里化等等。 作为值的函数 可以像任何其他数据类型一样被传递和操作的函数，每当你想要给算法传入具体动作时这个特性就会变得非常有用。 定义函数时格式：val 变量名 = (...
Spark-SparkSql中利用ConfigFactory获取配置文件详解
qq_824203453_的博客
06-13 1万+
  版权声明：本文为博主原创文章，未经博主允许不得转载!! 欢迎访问:https://blog.csdn.net/qq_21439395/article/details/80678524 交流QQ: 824203453   1. 获取配置文件中的配置 1.1.  简述 在实际的开发中，工程中的一些配置会放在classpath下的配置文件中，然后在程序代码中，会对配置文件进行加载使用。...
scala语言
qq_41953252的博客
10-04 495
文章目录scala语言课程设计一、课前准备二、课堂主题三、课堂目标四、知识要点1. scala简介2. 为什么要使用scala3. 开发环境安装3.1 安装JDK3.2 安装scala SDK3.3 安装IDEA的scala插件4. scala的REPL交互式解释器5. scala中声明变量6. scala中数据类型7. scala中的条件表达式8. scala中的块表达式9. 循环9.1 fo...
scala 中配置文件之 config
weixin_30698297的博客
01-08 1054
Typesafe的Config库，纯Java写成、零外部依赖、代码精简、功能灵活、API友好。支持Java properties、JSON、JSON超集格式HOCON以及环境变量。它也是Akka的配置管理库. Overview 纯java实现，无任何依赖 充分的测试 支持: Java properties, JSON, and a human-friendly JSON superse...
Scala高阶函数深度解析：抽象、柯里化与控制
在Scala编程语言中，高阶函数是一种高级特性，它将函数作为第一类对象进行处理，使得我们可以像操作其他数据类型（如数字、字符串）一样来操作函数。本文将深入探讨以下几个关键概念： 1. **作为值的函数**: 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值