学亮编程手记

scala隐式函数的本质是一个柯里化函数

（1）首先会在当前代码作用域下查找隐式实体（隐式方法、隐式类、隐式对象）。（2）如果第一条规则查找隐式实体失败，会继续在隐式参数的类型的作用域里查找。类型的作用域是指与该类型相关联的全部伴生对象以及该类型所在包的包对象。

在 Scala2.10 后提供了隐式类，可以使用 implicit 声明类，隐式类的非常强大，同样可以扩展类的功能，在集合中隐式类会发挥重要的作用。（2）隐式类必须被定义在“类”或“伴生对象”或“包对象”里，即隐式类不能是顶。（1）其所带的构造参数有且只能有一个。

普通方法或者函数中的参数可以通过 implicit 关键字声明为隐式参数，调用该方法时，就可以传入该参数，编译器会在相应的作用域寻找符合条件的隐式值。（2）编译器按照隐式参数的类型去寻找对应类型的隐式值，与隐式值的名称无关。（1）同一个作用域中，相同类型的隐式值只能有一个。（3）隐式参数优先于默认参数。

隐式转换可以在不需改任何代码的情况下，扩展某个类的功能。需求：通过隐式转换为 Int 类型增加方法。

【代码】scala基础：异常处理。

代码】scala object class基础语法讲解。

<dependency> <groupId>org.scala-lang</groupId> <artifactId>scala-library</artifactId> <version>2.11.12</version> </dependency>添加了上述配置后idea的scala插件还是得安装，只是为了解决scal

只能通过当前类名NioUtil调用静态成员package com.zxl.scalaimport cn.hutool.core.io.{FileUtil, IoUtil, NioUtil}import java.io.BufferedInputStreamimport java.io.BufferedOutputStreamobject HuToolsDemo { def main(args: Array[String]): Unit = { val in: BufferedInp

object BibaoDemo { def main(args: Array[String]): Unit = { val f: String => String = makeSuffix(".jpg") println(f("d.jpg")) println(f("c.jpg")) } def makeSuffix(suffix: String): String => String = { (filename: String) => {..

启动一个Scala项目，有两种方法：利用App特质：object Application extends App { println("Hello World")}使用main：object Application { def main(args: Array[String]): Unit = { println("Hello World"); }}那么，这两种启动项目的方式有什么不同呢？App是scala语言内置的一个特质，使用它，则把对应obje

SCALA安装：JAVA.LANG.NUMBERFORMATEXCEPTION: FOR INPUT FOR INPUT STRING: “0X100”问题描述Linux终端输入scala进入其shell时报错：[ERROR]Failed to construct terminal;falling back to unsupportedjava.lang.NumberFormatException: For input string: "0x100"解决办法打开Scala环境变量配置文件，添

引言传统解决思路package com.zxl.scalaobject PartiakFunDemo1 { def main(args: Array[String]): Unit = { val list: List[Any] = List(1, 2, 3, 4, "abc") val list1: List[Any] = list.filter(_.isInstanceOf[Int]) val list2: List[Int] = list1.map(_.asInst

参考链接：https://blog.csdn.net/qq_39597203/article/details/83006695

Scala 类和对象类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。我们可以使用 new 关键字来创建类的对象，实例如下：class Point(xc: Int, yc: Int) { var x: Int = xc var y: Int = yc def move(dx: Int, dy: Int) { x = x + dx y = y

Scala Iterator（迭代器）Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。迭代器 it 的两个基本操作是 next 和 hasNext。调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。调用 it.hasNext() 用于检测集合中是否还有元素。让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环：object Test { def main(args: Array[String]) { val

Scala CollectionScala提供了一套很好的集合实现，提供了一些集合类型的抽象。Scala 集合分为可变的和不可变的集合。可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。而不可变集合类，相比之下，永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。接下来我们将为大家介绍几种常用集合类型的应用：序号集合及描述1Scala List(列表)List的

Scala 数组Scala 语言中提供的数组是用来存储固定大小的同类型元素，数组对于每一门编辑应语言来说都是重要的数据结构之一。声明数组变量并不是声明 number0、number1、…、number99 一个个单独的变量，而是声明一个就像 numbers 这样的变量，然后使用 numbers[0]、numbers[1]、…、numbers[99] 来表示一个个单独的变量。数组中某个指定的元素是通过索引来访问的。数组的第一个元素索引为0，最后一个元素的索引为元素总数减1。声明数组以下是 Scal

Scala 字符串以下实例将字符串赋值给一个常量：object Test { val greeting: String = "Hello,World!" def main(args: Array[String]) { println( greeting ) }}以上实例定义了变量 greeting，为字符串常量，它的类型为 String (java.lang.String)。在 Scala 中，字符串的类型实际上是 Java String，它本身没有 String

Scala 闭包闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。如下面这段匿名的函数：val multiplier = (i:Int) => i * 10函数体内有一个变量 i，它作为函数的一个参数。如下面的另一段代码：val multiplier = (i:Int) => i * factor在 multiplier 中有两个变量：i 和 factor。其中的一个 i 是函数的形式参数，在 m

Scala 函数函数是一组一起执行一个任务的语句。 您可以把代码划分到不同的函数中。如何划分代码到不同的函数中是由您来决定的，但在逻辑上，划分通常是根据每个函数执行一个特定的任务来进行的。Scala 有函数和方法，二者在语义上的区别很小。Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。我们可以在任何地方定义函数，甚至可以在函数内定义函数（内嵌函数）。更重要的一点是 Scala 函数名可以有以下特殊字符：+, ++, ~, &,-, – ,

Scala变量变量是程序的基本组成单位不论是使用哪种高级程序语言编写程序,变量都是其程序的基本组成单位，比如:object ScalaFuncDemo01 { def main(args: Array[String]): Unit = { var a:Int = 1 //定义一个整型变量，取名为a，并赋值为1 var b:Int = 3 //定义一个整型变量，取名为b，并赋值为3 b=89 println("a="+a) println("b="+b)

package com.msb.bigdata.scala//约等于 static 单例对象//static//单例 new scala的编译器很人性化 让你人少写了很多代码object ooxx { // private val xo:xxoo = new xxoo() private val xo = new ooxx(11) // Integer num = 0; // var/val var:变量 val常量 取代了final /* va

http://www.voidcn.com/article/p-mpirtzuw-bve.html

object S { def main(args: Array[String]): Unit = { println("scala") val arr: Array[Int] = Array(1, 2, 3, 4, 5, 6) val res: Array[Int] = arr.filter(_ % 2 == 0).map(_ * 2) res.foreach(println) }}

场景两个Executor，分别接收来自Driver分发的任务（数据和计算逻辑）代码Executor1package com.zxl.bigdata.spark.core.testimport java.io.{InputStream, ObjectInputStream}import java.net.{ServerSocket, Socket}object Executor { def main(args: Array[String]): Unit = {

https://www.jianshu.com/p/461671002589

https://blog.csdn.net/weixin_46034893/article/details/114112163scala 创建二维数组的方法跟 java 有一些区别，研究了好一会，终于写出来了1、val arr = Array[Array[Int]](Array(1,2,3),Array(4,2,1))这个就是创建了一个 2 * 2 的数组，相当于java中的 int[][] arr = new int[][]{{1,2,3},{4,2,1}};这种创建二维数组的方法可以直接赋值

最终效果Masterpackage cn.zxl.spark.masterimport akka.actor.{Actor, ActorRef, ActorSystem, Props}import cn.zxl.spark.common.{HeartBeat, RegisterWorkerInfo, RegisteredWorkerInfo, WorkerInfo}import com.typesafe.config.ConfigFactoryimport scala.collectio

最终效果master：worker：思路分析Master代码package cn.zxl.spark.masterimport akka.actor.{Actor, ActorRef, ActorSystem, Props}import cn.zxl.spark.common.{RegisterWorkerInfo, RegisteredWorkerInfo, WorkerInfo}import com.typesafe.config.ConfigFactoryimport s

最终效果Server端package cn.zxl.akka.serverimport akka.actor._import cn.zxl.akka.common.{ClientMessage, ServerMessage}import com.typesafe.config.ConfigFactory/** * @description: * @author: zhangxueliang * @create: 2021-05-29 16:07 * @version: 1.0 *

代码package cn.zxl.actorimport akka.actor.{Actor, ActorRef, ActorSystem, Props}/** * @description: * @author: zhangxueliang * @create: 2021-05-29 15:51 * @version: 1.0 * *///当我们继承 Actor 后，就是一个 Actor,核心方法 receive 方法重写class SayHelloActor extends Ac

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</mo

详解Scala中的类及与Java的详细区别

详解Scala函数也是对象的特性

详解Scala与Java的互动