Scala的知识点总结

Scala：

官网:https://www.scala-lang.org/

在线帮助手册:https://docs.scala-lang.org/

快速开始:https://docs.scala-lang.org/getting-started.html

scala之旅:手册:https://docs.scala-lang.org/tour/tour-of-scala.html

特性

scala是什么？

Scala是一门现代的多范式语言，志在以简洁、优雅及类型安全的方式来表达常用的编程模型。它平滑地集成了面向对象和函数式语言的特性。

• Scala是面向对象的
• Scala是函数式的
• Scala是静态类型的
• Scala是可扩展的
• Scala的互操作性

在线编程

​ 可以在浏览器上使用ScalaFiddle运行Scala，打开https://scalafiddle.io

类型

Any是所有类型的超类型，也称为顶级类 型。

• 它定义了一些通用的方法如equals、hashCode和toString 。Any有两个直接子类：AnyVal和AnyRef。(Object)

AnyVal代表值类型。有9个预定义的非空的值类型分别是：Double、Float、Long、Int、Short、Byte、Char、Unit和Boolean。

• Unit是不带任何意义的值类型，它仅有一个实例可以像这样声明：()。所有的函数必须有返回，所以说有时候Unit也是有用的返回类型。(基本数据类型)

AnyRef代表引用类型。所有非值类型都被定义为引用类型。在Scala中，每个用户自定义的类型都是AnyRef的子类型。

• 如果Scala被应用在Java的运行环境中，AnyRef相当于java.lang.Object。

转型

Nothing和Null

• Nothing是所有类型的子类型，也称为底部类型。没有一个值是Nothing类型的。它的用途之一是给出非正常终止的信号，如抛出异常、程序退出或者一个无限循环（可以理解为它是一个不对值进行定义的表达式的类型，或者是一个不能正常返回的方法）。

退出或者一个无限循环（可以理解为它是一个不对值进行定义的表达式的类型，或者是一个不能正常返回的方法）。

• l Null是所有引用类型的子类型（即AnyRef的任意子类型）。它有一个单例值由关键字null所定义。Null主要是使得Scala满足和其他JVM语言的互操作性，但是几乎不应该在Scala代码中使用。我们将在后面的章节中介绍null的替代方案。

什么是scala

Scala是一门以java虚拟机为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言。

scala 的特点

作为一门语言非常简洁高效，是一门多范式的编程语言，支持面向对象和函数式编程。 编译成成Java字节码，然后运行于JVM之上，并可以调用现有的java类库，实现两种语言的无缝对接。 将函数式编程语言的特点融合到JAVA中。 函数是头等公民

scala和java 有什么区别？

1,变量的声明 变量var 常量val scala支持自动类型推测 scala更多的是采用常量,而不是变量来解决问题,这样带来的好处是可以减少多线程并发安全问题,特别适合用于多并发分布式的场景
2,函数的声明 关键字def, Scala函数没有返回值用Unit，相当于java的void Scala支持函数式编程,可以使用高阶函数 函数是一等公民
3,基本类型 其实可以认为scala中并没有真正意义上的基本类型,他的类型都是类
4,静态 java中静态static是违背java面向对象的编程思想和封装特性的,scala取消了静态的概念,使用了单例对象Object来实现
5,对字符串的支持 Scala支持使用字符串插值的方式对字符串进行格式化,使用$开头进行取值 另外支持使用三引号将其中的内容直接包起来,其中可以包括任何字符而不需要转义
6,类 Scala类中的字段自动带有getter和setter方法,另外可以使用@BeanProperty注解来生成java中的Get/Set方法 Scala中的每个类都有一个主构造器,这个构造器和类定义”交织在一起”,类的参数直接成为类的字段,主构造器执行类体中所有的语句
7,Scala中不支持Break 使用return替代 在循环中用if和布尔类型变量进行守卫 导入java中支持break的包
8,访问范围问题 java中外部看不到内部,内部能看到外部 scala中外部看不到内部,内部看不到外部
9,通配符 Java使用*进行通配,Scala使用 _ 进行通配
10,默认导入的类 scala默认导入java.lang包、scala包、scala.Predef类。 java默认导入java.lang包 1
1,特质 trait – 可以类比java中的接口，但是又和接口非常不一样 java中称为类实现了接口 scala中称为混入了特质 和java中的接口不同 scala中的特质可以包含 带有方法体的方法 *

val 和var的区别？

val是常量 var是变量

scala的数据类型？

Any是所有类型地超类型，也称为顶级类型。它定义了一些通过地方法如：equals，hashCode和toString。Any有两个直接子类：AnyVal和AnyRef。（Object） AnyVal代表值类型。有9个预定义地非空地值类型分别是：Double，Float，Long，Int，Short，Byte，Char，Unit和Boolean。Unit是不带任何意义地值类型。它仅有一个实例可以像这样声明：（）。所有地函数必须有返回，所以说有时候Unit也是有用返回类型（基本数据类型） AnyRef代表引用类型。所有非值类型都被定义为引用类型。在Scala中，每个用户自定义地类型都是ANyRef地子类型。如果Scala被应用在java地运行环境中，AnyRef相当于java.lang.Object。

scala 运算符

算术运算符 关系运算符 逻辑运算符 赋值运算符 位运算符

scala块语句有什么特点？

最后一行的值或者方法体作为返回值

scala break使用?

需要先引入类 import util.control.Breaks._

scala 函数和方法的区别？

一个带>一个不带 （1）为完成某一功能的程序指令（语句）的集合，称为函数。
（2）类中的函数称之方法。
2）案例实操 （1）Scala语言的语法非常灵活，可以在任何的语法结构中声明任何的语法
（2）函数没有重载和重写的概念；方法可以进行重载和重写
（3）scala中函数可以嵌套定义 Scala 有方法与函数，二者在语义上的区别很小。Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。 Scala 中的方法跟 Java 的类似，方法是组成类的一部分。 Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。 Scala 中使用 val 语句可以定义函数，def 语句定义方法。

scala 函数的参数？

可变参数 如果参数列表中存在多个参数，那么可变参数一般放置在最后 参数默认值 带名参数 11. s

scala 方法的几种写法？

（1）函数1：无参，无返回值
（2）函数2：无参，有返回值
（3）函数3：有参，无返回值
（4）函数4：有参，有返回值
（5）函数5：多参，无返回值

scala 函数的写法

scala 闭包？

就是****一个函数*和与*其相关的引用环境（变量）*组合的一个*整体****(实体)

scala 柯里化？

将一个接收多个参数的函数转化成一个接受一个参数的函数过程，可以简单的理解为一种特殊的参数列表声明方式

scala 函数至简原则？

至简原则细节
（1）return可以省略，Scala会使用函数体的最后一行代码作为返回值
（2）返回值类型如果能够推断出来，那么可以省略
（3）如果函数体只有一行代码，可以省略花括号
（4）如果函数无参，则可以省略小括号。若定义函数时省略小括号，则调用该函数时，也需省略小括号；若定时函数时未省略，则调用时，可省可不省。
（5）如果函数明确声明Unit，那么即使函数体中使用return关键字也不起作用
（6）Scala如果想要自动推断无返回值，可以省略等号
（7）如果不关心名称，只关系逻辑处理，那么函数名（def）可以省略
（8）如果函数明确使用return关键字，那么函数返回就不能使用自行推断了，需要声明返回值类型

scala lazy？

当**函数返回值被声明为lazy时**，函数的执行将被推迟，直到我们再次对此取值，该函数才会执行。这种函数我们称之为惰性函数。

scala包的三大作用

Scala包的三大作用（和Java一样） （1）区分相同名字的类 （2）当类很多时，可以很好的管理类 （3）控制访问范围

scala中的三个默认导入包

*importjava.lang._* *importscala._* *import scala.Predef._*

scala访问修饰符，以及作用域 在Java中，访问权限分为：

public，private，protected和默认。在Scala中，你可以通过类似的修饰符达到同样的效果。但是使用上有区别。 （1）scala 中属性和方法的默认访问权限为public，但scala中无public关键字。 （2）private为私有权限，只在类的内部和伴生对象中可用。 （3）protected为受保护权限，Scala中受保护权限比Java中更严格，同类、子类可以访问，同包无法访问。 （4）private[包名]增加包访问权限，包名下的其他类也可以使用

scala@BeanProperty属性的特点

Bean属性（@BeanPropetry），可以自动生成规范的setXxx/getXxx方法

scala var和val修饰的对象有什么区别

val修饰对象，不能改变对象的引用（即：内存地址），可以改变对象属性的值。 （2）var修饰对象，可以修改对象的引用和修改对象的属性值

scala的构造器 和Java一样，Scala构造对象也需要调用构造方法，并且可以有任意多个构造方法。

Scala类的构造器包括：

*主构造器和辅助构造器*

（1）辅助构造器，函数的名称this，可以有多个，编译器通过参数的个数来区分。 （2）辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法。 如果主构造器无参数，小括号可省略，构建对象时调用的构造方法的小括号也可以省略。

Scala类的主构造器函数的形参包括三种类型：未用任何修饰、var修饰、val修饰 （1）未用任何修饰符修饰，这个参数就是一个局部变量 （2）var修饰参数，作为类的成员属性使用，可以修改 （3）val修饰参数，作为类只读属性使用，不能修改

scala的继承class 子类名extends父类名 {类体}

（1）子类继承父类的****属性*和*方法**** （2）scala是单继承 子类继承父类的****属性*和*方法**** （2）继承的调用顺序：父类构造器->子类构造器

scala的抽象类

（1）定义抽象类：abstract class Person{} //通过abstract关键字标记抽象类 （2）定义抽象属性：val|var name:String//一个属性没有初始化，就是抽象属性 （3）定义抽象方法：def hello():String//只声明而没有实现的方法，就是抽象方法

scala的内部类访问的方法（俩中）

第一种 通过new 外部类对象.内部类 创建内部类对象 通过外部类暴露一个内部类对象的方法

scala object的特点？

下面的对象都是单例静态的

scala伴生类和伴生对象有什么特点

Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为****单例对象****。若单例对象名与类名一致，则称该单例对象这个类的****伴生对象****，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。 单例对象采用object关键字声明 （2）单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。 （3）单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。

scala的apply

（1）通过伴生对象的apply方法，实现不使用new方法创建对象。 （2）如果想让主构造器变成私有的，可以在()之前加上private。 （3）apply方法可以重载。 （4）Scala中****obj(arg)*的语句实际是在调用该对象的*apply****方法，即obj.apply(arg)。用以同一面向对象编程和函数式编程的风格。

scala的特质trait

Scala语言中，采用特质trait（特征）来代替接口的概念，也就是说，多个类具有相同的特征（特征）时，就可以将这个特质（特征）独立出来，采用关键字trait声明。 Scala中的trait中即****可以有抽象属性和方法，也可以有具体的属性和方法****，****一个类可以混入（mixin）多个特质****。 Scala引入trait特征，第一可以替代Java的接口，第二个也是对单继承机制的一种补充。

scala的类型检查和转换

//首先做类型检查 isInstanceOf 只能判断是不是其本身或者子类 不能坐精确的判断 // if(obj.isInstanceOf[StudentInstance]){ // //做类型转换 // val instance = obj.asInstanceOf[StudentInstance] // instance.getInfo // }else if(obj.isInstanceOf[WorkerInstance]){ // //做类型转换 // val instance = obj.asInstanceOf[WorkerInstance] // instance.getInfo // } //使用getclass == classOf 直接拿类名做比较，可以做精确的判断 if(obj.getClass == classOf[StudentInstance]){ //做类型转换 val instance = obj.asInstanceOf[StudentInstance] instance.getInfo }else if(obj.getClass == classOf[WorkerInstance]){ //做类型转换 val instance = obj.asInstanceOf[WorkerInstance] instance.getInfo

scala的数组

*不可变数组* 1）第一种方式定义数组(定长数组) 定义：val arr1 = new ArrayInt （1）new是关键字 （2）[Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定Any （3）(10)，表示数组的大小，确定后就不可以变化 定义数组 val arr1 = Array(1, 2) （1）在定义数组时，直接赋值 （2）使用apply方法创建数组对象

*可变数组* 1）定义变长数组 val arr01 = ArrayBuffer[Any](3, 2, 5) （1）[Any]存放任意数据类型 （2）(3, 2, 5)初始化好的三个元素 （3）ArrayBuffer需要引入scala.collection.mutable.ArrayBuffer ArrayBuffer是有序的集合 （2）增加元素使用的是append方法()，支持可变参数
*不可变数组与可变数组的转换* 1）说明 arr1.toBuffer //****不可长数组转可变数组**** arr2.toArray //****可变数组转不可变数组**** （1）arr2.toArray返回结果才是一个不可变数组+，arr2本身没有变化 （2）arr1.toBuffer返回结果才是一个可变数组，arr1本身没有变化
*多维数组* 1）多维数组定义 val arr =Array.ofDimDouble 说明：二维数组中有三个一维数组，每个一维数组中有四个元素

scala的list

*不可变List* 1）说明 （1）List默认为不可变集合 （2）创建一个List（数据有顺序，可重复） （3）遍历List （4）List增加数据 （5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化 （6）取指定数据 （7）空集合Nil

*可变ListBuffer* 1）说明 （1）创建一个可变集合ListBuffer （2）向集合中添加数据 （3）打印集合数据 33. scala的map Scala中的Map和Java类似

，****也是一个散列表****，它存储的内容也是键值对（****key-value）****映射，Scala中

****不可变的Map是有序的****，可变的

****Map是无序的****。 *不可变Map* 1）说明 （1）创建不可变集合Map （2）循环打印 （3）访问数据 （4）如果key不存在，返回0

*可变Map* 1）说明 （1）创建可变集合 （2）打印集合 （3）向集合增加数据 （4）删除数据 （5）修改数据 34. scala的set 默认情况下，Scala使用的是不可变集合，如果你想使用可变集合，需要引用scala.collection.mutable.Set包

*不可变Set* 1）说明 （1）Set默认是不可变集合，数据无序 （2）数据不可重复 （3）遍历集合

*不可变mutable.Set* 1）说明 （1）创建可变集合mutable.Set （2）打印集合 （3）集合添加元素 （4）向集合中添加元素，返回一个新的Set （5）删除数据

scala的集合的head tail Nil？

构造列表是有两个基本类型Nil和:: //Nill也可以表示一个空列表
Scala列表有三个基本操作 /* head返回列表第一个元素tail返回一个列表，包含除了第一个元素之外的其他元素isEmpty在列表为空时返回true

scala的并行集合

Scala为了充分使用****多核CPU****，提供了并行集合（有别于前面的串行集合），用于多核环境的并行计算。

scala的队列

scala也提供了队列（Queue）的数据结构，队列的特点就是先进先出。进队和出队的方法分别为enqueue和dequeue。

样例类的特点？

案例类非常适合用于不可变的数据 不能使用new来创建对象,这是因为案例类有一个默认的apply方法来负责对象的创建。 使用==比较,可以直比较堆和栈的上的值 当你创建包含参数的案例类时，这些参数是公开（public）的val,不能为案例类的属性重新赋值 拷贝:浅拷贝,只拷贝类的属性中(基本数据类型);深拷贝(不但拷贝基本数据类型还要拷贝引用数据类型) 密封类 特质（trait）和类（class）可以用sealed标记为密封的，这意味着其所有子类都必须与之定义在相同文件中，从而保证所有子类型都是已知的。
（1）语法： ****case class****Person (name: String, age: Int)

（2）说明 1样例类仍然是类，和普通类相比，只是其自动生成了伴生对象，并且伴生对象中自动提供了一些常用的方法，如****apply****、****unapply****、****toString****、equals、hashCode和copy。 2样例类是为模式匹配而优化的类，因为其默认提供了unapply方法，因此，样例类可以直接使用模式匹配，而无需自己实现unapply方法。 3构造器中的每一个参数都成为val，除非它被显式地声明为var（不建议这样做）

scala的模式匹配

Scala中的模式匹配类似于Java中的switch语法，但是更加强大。 模式匹配语法中，采用match关键字声明，每个分支采用case关键字进行声明，当需要匹配时，会从第一个case分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断。如果所有case都不匹配，那么会执行case _分支，类似于Java中default语句。

说明 （1）如果所有case都不匹配，那么会执行case _分支，类似于Java中default语句，若没有case _分支，那么会抛出MatchError。

（2）每个case中，不用break语句，自动中断case。

（3）match case语句可以匹配任何类型，而不只是字面量。

（4）=>后面的代码块，是****作为一个整体执行****，可以使用{}括起来，也可以不括。

scala的偏函数

偏函数也是函数的一种，通过偏函数我们可以方便的对输入参数做更精确的检查。例如该偏函数的输入类型为List[Int]，而我们需要的是第一个元素是0的集合，这就是通过模式匹配实现的。偏函数的功能能是返回输入的List集合的第二个元组

scala的异常

1）我们将可疑代码封装在try块中。在try块之后使用了一个catch处理程序来捕获异常。如果发生任何异常，catch处理程序将处理它，程序将不会异常终止。

2）Scala的异常的工作机制和Java一样，但是Scala没有“checked（编译期）”异常，即Scala没有编译异常这个概念，异常都是在运行的时候捕获处理。

3）异常捕捉的机制与其他语言中一样，如果有异常发生，catch子句是按次序捕捉的。因此，在catch子句中，越具体的异常越要靠前，越普遍的异常越靠后，如果把越普遍的异常写在前，把具体的异常写在后，在Scala中也不会报错，但这样是非常不好的编程风格。

4）finally子句用于执行不管是正常处理还是有异常发生时都需要执行的步骤，一般用于对象的清理工作，这点和Java一样。

5）用throw关键字，抛出一个异常对象。所有异常都是Throwable的子类型。throw表达式是有类型的，就是Nothing，因为Nothing是所有类型的子类型，所以throw表达式可以用在需要类型的地方 def test():Nothing = { throw new Exception(“不对”) }

6）Scala提供了throws关键字来声明异常。可以使用方法定义声明异常。它向调用者函数提供了此方法可能引发此异常的信息。它有助于调用函数处理并将该代码包含在try-catch块中，以避免程序异常终止。在Scala中，可以使用throws注释来声明异常