本文详细介绍了Scala语言，从其基本概念、下载安装、基础语法、数据类型、运算符、控制流、函数与方法、字符串、数组、集合、迭代器、类与对象、特质、模式匹配、正则表达式、异常处理等方面进行全面讲解，旨在帮助读者掌握Scala编程的基础知识和应用。特别强调了Scala的多范式特性，包括面向对象和函数式编程，以及并发处理能力，适合于想学习或深入理解Scala的开发者参考。
目录
一、Scala简介
Scala是什么
Scala是一门多范式的编程语言，一种类似java的编程语言，设计初衷是实现可伸缩的语言、并集成面向对象编程和函数式编程的各种特性。
Scala的特性
面向对象特性
Scala是一种纯面向对象的语言，每个值都是对象。对象的数据类型以及行为由类和特质描述。
类抽象机制的扩展有两种途径：一种途径是子类继承，另一种途径是灵活的混入机制。这两种途径能避免多重继承的种种问题。
函数式编程
Scala也是一种函数式语言，其函数也能当成值来使用。Scala提供了轻量级的语法用以定义匿名函数，支持高阶函数，允许嵌套多层函数，并支持柯里化。Scala的case class及其内置的模式匹配相当于函数式编程语言中常用的代数类型。
更进一步，程序员可以利用Scala的模式匹配，编写类似正则表达式的代码处理XML数据。
静态类型
Scala具备类型系统，通过编译时检查，保证代码的安全性和一致性。类型系统具体支持以下特性：
- 泛型类
- 协变和逆变
- 标注
- 类型参数的上下限约束
- 把类别和抽象类型作为对象成员
- 复合类型
- 引用自己时显式指定类型
- 视图
- 多态方法
扩展性
Scala的设计秉承一项事实，即在实践中，某个领域特定的应用程序开发往往需要特定于该领域的语言扩展。Scala提供了许多独特的语言机制，可以以库的形式轻易无缝添加新的语言结构：
- 任何方法可用作前缀或后缀操作符
- 可以根据预期类型自动构造闭包。
并发性
Scala使用Actor作为其并发模型，Actor是类似线程的实体，通过邮箱发收消息。Actor可以复用线程，因此可以在程序中可以使用数百万个Actor,而线程只能创建数千个。在2.10之后的版本中，使用Akka作为其默认Actor实现。
Scala应用场景
- kafka：分布式消息队列，内部代码经常用来处理并发的问题，用scala可以大大简化其代码。
- spark：方便处理多线程场景，另外 spark 主要用作内存计算，经常要用来实现复杂的算法。利用scala 这种函数式编程语言可以大大简化代码。
二、Scala下载安装
在window中操作
下载地址：Install | The Scala Programming Language
接下来将压缩包解压安装即可
本文以scala-2.12.11为例
解压压缩包到你的电脑
配置环境变量
配置SCALA_HOME为你的scala地址
在PATH中添加%SCALA_HOME%\bin
win+r输入cmd，进入终端后输入scala验证是否安装成功。
三、Scala基础
基本语法
- 区分大小写
- Scala是大小写敏感的
- 类名（驼峰规则）
- 对于所有的类名的第一个字母要大写。
- 如果需要使用几个单词来构成一个类的名称，每个单词的第一个字母要大写。
- 方法名称
- 所有的方法名称的第一个字母要小写
- 如果若干个单词被用于构成方法的名称，则每个单词的第一个字母应大写。
- 程序文件名
- 程序文件的名称应该与对象名称完全匹配(新版本不需要了，但建议保留这种习惯)。
- 保存文件时，应该保存它使用的对象名称（记住Scala是区分大小写），并追加".scala"为文件扩展名
标识符
Scala 可以使用两种形式的标志符，字符数字和符号。
字符数字使用字母或是下划线开头，后面可以接字母或是数字，符号"$"在 Scala 中也看作为字母。然而以"$"开头的标识符为保留的 Scala 编译器产生的标志符使用，应用程序应该避免使用"$"开始的标识符，以免造成冲突。
Scala 的命名规则采用和 Java 类似的 camel 命名规则，首字符小写，比如 toString。类名的首字符还是使用大写。此外也应该避免使用以下划线结尾的标志符以避免冲突。符号标志符包含一个或多个符号，如+，:，? 等，比如:
+ ++ ::: < ?> :->
Scala 内部实现时会使用转义的标志符，比如:-> 使用 $colon$minus$greater 来表示这个符号。因此如果你需要在 Java 代码中访问:->方法，你需要使用 Scala 的内部名称 $colon$minus$greater。
混合标志符由字符数字标志符后面跟着一个或多个符号组成，比如 unary_+ 为 Scala 对+方法的内部实现时的名称。字面量标志符为使用"定义的字符串，比如 `x` `yield`。
你可以在"之间使用任何有效的 Scala 标志符，Scala 将它们解释为一个 Scala 标志符，一个典型的使用为 Thread 的 yield 方法， 在 Scala 中你不能使用 Thread.yield()是因为 yield 为 Scala 中的关键字， 你必须使用 Thread.`yield`()来使用这个方法。
Scala 关键字
下表列出了 scala 保留关键字，我们不能使用以下关键字作为变量：
| abstract | case | catch | class |
| def | do | else | extends |
| false | final | finally | for |
| forSome | if | implicit | import |
| lazy | match | new | null |
| object | override | package | private |
| protected | return | sealed | super |
| this | throw | trait | try |
| true | type | val | var |
| while | with | yield | |
| - | : | = | => |
| <- | <: | <% | >: |
| # | @ |
Scala 注释
Scala 类似 Java 支持单行和多行注释。多行注释可以嵌套，但必须正确嵌套，一个注释开始符号对应一个结束符号。注释在 Scala 编译中会被忽略，实例如下：
object HelloWorld {
/* 这是一个 Scala 程序
* 这是一行注释
* 这里演示了多行注释
*/
def main(args: Array[String]) {
// 输出 Hello World
// 这是一个单行注释
println("Hello, world!")
}
}Scala 数据类型
Scala 与 Java有着相同的数据类型，下表列出了 Scala 支持的数据类型：
| 数据类型 | 描述 |
|---|---|
| Byte | 8位有符号补码整数。数值区间为 -128 到 127 |
| Short | 16位有符号补码整数。数值区间为 -32768 到 32767 |
| Int | 32位有符号补码整数。数值区间为 -2147483648 到 2147483647 |
| Long | 64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807 |
| Float | 32 位, IEEE 754 标准的单精度浮点数 |
| Double | 64 位 IEEE 754 标准的双精度浮点数 |
| Char | 16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF |
| String | 字符序列 |
| Boolean | true或false |
| Unit | 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。 |
| Null | null 或空引用 |
| Nothing | Nothing类型在Scala的类层级的最底端；它是任何其他类型的子类型。 |
| Any | Any是所有其他类的超类 |
| AnyRef | AnyRef类是Scala里所有引用类(reference class)的基类 |
上表中列出的数据类型都是对象，也就是说scala没有java中的原生类型。在scala是可以对数字等基础类型调用方法的。
Scala 基础字面量
Scala 非常简单且直观。接下来我们会详细介绍 Scala 字面量。
整型字面量
整型字面量用于 Int 类型，如果表示 Long，可以在数字后面添加 L 或者小写 l 作为后缀。：
0
035
21
0xFFFFFFFF
0777L浮点型字面量
如果浮点数后面有f或者F后缀时，表示这是一个Float类型，否则就是一个Double类型的。实例如下：
0.0
1e30f
3.14159f
1.0e100
.1布尔型字面量
布尔型字面量有 true 和 false。
符号字面量
符号字面量被写成： '<标识符> ，这里 <标识符> 可以是任何字母或数字的标识（注意：不能以数字开头）。这种字面量被映射成预定义类scala.Symbol的实例。
如： 符号字面量 'x 是表达式 scala.Symbol("x") 的简写，符号字面量定义如下：
package scala
final case class Symbol private (name: String) {
override def toString: String = "'" + name
}字符字面量
在 Scala 字符变量使用单引号 ' 来定义，如下：
'a'
'\u0041'
'\n'
'\t'其中 \ 表示转义字符，其后可以跟 u0041 数字或者 \r\n 等固定的转义字符。
字符串字面量
在 Scala 字符串字面量使用双引号 " 来定义，如下：
"Hello,\nWorld!"多行字符串的表示方法
多行字符串用三个双引号来表示分隔符，格式为：""" ... """。
实例如下：
val foo = """嘤嘤嘤
哇哇哇
哈哈哈
噫噫噫
i love you ，so much"""Null 值
空值是 scala.Null 类型。
Scala.Null和scala.Nothing是用统一的方式处理Scala面向对象类型系统的某些"边界情况"的特殊类型。
Null类是null引用对象的类型，它是每个引用类（继承自AnyRef的类）的子类。Null不兼容值类型。
Scala 转义字符
下表列出了常见的转义字符：
| 转义字符 | Unicode | 描述 |
|---|---|---|
| \b | \u0008 | 退格(BS) ，将当前位置移到前一列 |
| \t | \u0009 | 水平制表(HT) （跳到下一个TAB位置） |
| \n | \u000a | 换行(LF) ，将当前位置移到下一行开头 |
| \f | \u000c | 换页(FF)，将当前位置移到下页开头 |
| \r | \u000d | 回车(CR) ，将当前位置移到本行开头 |
| \" | \u0022 | 代表一个双引号(")字符 |
| \' | \u0027 | 代表一个单引号（'）字符 |
| \\ | \u005c | 代表一个反斜线字符 '\' |
0 到 255 间的 Unicode 字符可以用一个八进制转义序列来表示，即反斜线‟\‟后跟 最多三个八进制。
在字符或字符串中，反斜线和后面的字符序列不能构成一个合法的转义序列将会导致 编译错误。
以下实例演示了一些转义字符的使用：
实例
object Test {
def main(args: Array[String]) {
println("请问一下你的年龄\n今年我18岁了")
}
}执行以上代码输出结果如下所示：
Scala 变量
变量是一种使用方便的占位符，用于引用计算机内存地址，变量创建后会占用一定的内存空间。
基于变量的数据类型，操作系统会进行内存分配并且决定什么将被储存在保留内存中。因此，通过给变量分配不同的数据类型，你可以在这些变量中存储整数，小数或者字母。
变量声明
在学习如何声明变量与常量之前，我们先来了解一些变量与常量。
- 一、变量： 在程序运行过程中其值可能发生改变的量叫做变量。如：时间，年龄。
- 二、常量：在程序运行过程中其值不会发生变化的量叫做常量。如：数值 3，字符'A'。
在 Scala 中，使用关键词 "var" 声明变量，使用关键词 "val" 声明常量。
声明变量实例如下：
var myVar : String = "Foo"
var myVar : String = "Too"以上定义了变量 myVar，我们可以修改它。
声明常量实例如下：
val myVal : String = "Foo"以上定义了常量 myVal，它是不能修改的。如果程序尝试修改常量 myVal 的值，程序将会在编译时报错。
变量类型声明
变量的类型在变量名之后等号之前声明。定义变量的类型的语法格式如下：
var VariableName : DataType [= Initial Value]
或
val VariableName : DataType [= Initial Value]
变量类型引用
在 Scala 中声明变量和常量不一定要指明数据类型，在没有指明数据类型的情况下，其数据类型是通过变量或常量的初始值推断出来的。
所以，如果在没有指明数据类型的情况下声明变量或常量必须要给出其初始值，否则将会报错。
var myVar = 10; val myVal = "Hello, Scala!";
以上实例中，myVar 会被推断为 Int 类型，myVal 会被推断为 String 类型。
Scala 多个变量声明
Scala 支持多个变量的声明：
val xmax, ymax = 100 // xmax, ymax都声明为100如果方法返回值是元组，我们可以使用 val 来声明一个元组：
scala> val pa = (40,"Foo")
pa: (Int, String) = (40,Foo)Scala 访问修饰符
Scala 访问修饰符基本和Java的一样，分别有：private，protected，public。
如果没有指定访问修饰符，默认情况下，Scala 对象的访问级别都是 public。
Scala 中的 private 限定符，比 Java 更严格，在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员。
私有(Private)成员
用 private 关键字修饰，带有此标记的成员仅在包含了成员定义的类或对象内部可见，同样的规则还适用内部类。
实例
class Outer{
class Inner{
private def f(): Unit ={
println("f")
}
class InnerMost{
f() // 正确
}
}
(new Inner).f() //错误
}
(new Inner).f( ) 访问不合法是因为 f 在 Inner 中被声明为 private，而访问不在类 Inner 之内。
但在 InnerMost 里访问 f 就没有问题的，因为这个访问包含在 Inner 类之内。
Java 中允许这两种访问，因为它允许外部类访问内部类的私有成员。
保护(Protected)成员
在 scala 中，对保护（Protected）成员的访问比 java 更严格一些。因为它只允许保护成员在定义了该成员的的类的子类中被访问。而在java中，用 protected关键字修饰的成员，除了定义了该成员的类的子类可以访问，同一个包里的其他类也可以进行访问。
实例
package p {
class Super {
protected def f() {println("f")}
}
class Sub extends Super {
f()
}
class Other {
(new Super).f() //错误
}
}上例中，Sub 类对 f 的访问没有问题，因为 f 在 Super 中被声明为 protected，而 Sub 是 Super 的子类。相反，Other 对 f 的访问不被允许，因为 other 没有继承自 Super。而后者在 java 里同样被认可，因为 Other 与 Sub 在同一包里。
公共(Public)成员
Scala 中，如果没有指定任何的修饰符，则默认为 public。这样的成员在任何地方都可以被访问。
实例
class Outer {
class Inner {
def f() { println("f") }
class InnerMost {
f() // 正确
}
}
(new Inner).f() // 正确因为 f() 是 public
}作用域保护
Scala中，访问修饰符可以通过使用限定词强调。格式为:
private[x]
或
protected[x]这里的x指代某个所属的包、类或单例对象。如果写成private[x],读作"这个成员除了对[…]中的类或[…]中的包中的类及它们的伴生对像可见外，对其它所有类都是private。
这种技巧在横跨了若干包的大型项目中非常有用，它允许你定义一些在你项目的若干子包中可见但对于项目外部的客户却始终不可见的东西。
实例
package bobsrockets{
package navigation{
private[bobsrockets] class Navigator{
protected[navigation] def useStarChart(){}
class LegOfJourney{
private[Navigator] val distance = 100
}
private[this] var speed = 200
}
}
package launch{
import navigation._
object Vehicle{
private[launch] val guide = new Navigator
}
}
}上述例子中，类 Navigator 被标记为 private[bobsrockets] 就是说这个类对包含在 bobsrockets 包里的所有的类和对象可见。
比如说，从 Vehicle 对象里对 Navigator 的访问是被允许的，因为对象 Vehicle 包含在包 launch 中，而 launch 包在 bobsrockets 中，相反，所有在包 bobsrockets 之外的代码都不能访问类 Navigator。
Scala 运算符
一个运算符是一个符号，用于告诉编译器来执行指定的数学运算和逻辑运算。
Scala 含有丰富的内置运算符，包括以下几种类型：
-
算术运算符
-
关系运算符
-
逻辑运算符
-
位运算符
-
赋值运算符
接下来将为大家详细介绍以上各种运算符的应用。
算术运算符
下表列出了 Scala 支持的算术运算符。
假定变量 A 为 10，B 为 20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加号 | A + B 运算结果为 30 |
| - | 减号 | A - B 运算结果为 -10 |
| * | 乘号 | A * B 运算结果为 200 |
| / | 除号 | B / A 运算结果为 2 |
| % | 取余 | B % A 运算结果为 0 |
实例
object Test {
def main(args: Array[String]) {
var a = 10;
var b = 20;
var c = 25;
var d = 25;
println("a + b = " + (a + b) );
println("a - b = " + (a - b) );
println("a * b = " + (a * b) );
println("b / a = " + (b / a) );
println("b % a = " + (b % a) );
println("c % a = " + (c % a) );
}
}执行以上代码，输出结果为：
$ scalac Test.scala
$ scala Test
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5关系运算符
下表列出了 Scala 支持的关系运算符。
假定变量 A 为 10，B 为 20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 | (A == B) 运算结果为 false |
| != | 不等于 | (A != B) 运算结果为 true |
| > | 大于 | (A > B) 运算结果为 false |
| < | 小于 | (A < B) 运算结果为 true |
| >= | 大于等于 | (A >= B) 运算结果为 false |
| <= | 小于等于 | (A <= B) 运算结果为 true |
实例
object Test {
def main(args: Array[String]) {
var a = 10;
var b = 20;
println("a == b = " + (a == b) );
println("a != b = " + (a != b) );
println("a > b = " + (a > b) );
println("a < b = " + (a < b) );
println("b >= a = " + (b >= a) );
println("b <= a = " + (b <= a) );
}
}执行以上代码，输出结果为：
$ scalac Test.scala
$ scala Test
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false逻辑运算符
下表列出了 Scala 支持的逻辑运算符。
假定变量 A 为 1，B 为 0：
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 逻辑与 | (A && B) 运算结果为 false |
| || | 逻辑或 | (A || B) 运算结果为 true |
| ! | 逻辑非 | !(A && B) 运算结果为 true |
实例
object Test {
def main(args: Array[String]) {
var a = true;
var b = false;
println("a && b = " + (a&&b) );
println("a || b = " + (a||b) );
println("!(a && b) = " + !(a && b) );
}
}执行以上代码，输出结果为：
$ scalac Test.scala
$ scala Test
a && b = false
a || b = true
!(a && b) = true位运算符
位运算符用来对二进制位进行操作，~,&,|,^ 分别为取反，按位与，按位或，按位异或运算，如下表实例：
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
如果指定 A = 60; 及 B &#
最低0.47元/天 解锁文章
670
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
