目录
目录
第一部分 Scala基础
第1节 Scala语言概况
1.1 Scala语言起源
马丁·奥德斯基（Martin Odersky）是编译器及编程的狂热爱好者。
主流JVM的Javac编译器就是马丁·奥德斯基编写出来的，JDK5.0、JDK8.0的编译器就是他写的。
长时间的编程之后，他希望发明一种语言，能够让写程序这样的基础工作变得高效，简单。
当接触到Java语言后，对Java这门语言产生了极大的兴趣，所以决定将函数式编程语言的特点融合到Java中，由此发明了Scala。
1.2 Scala语言特点
Scala是一门以 JVM 为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言。
Scala源代码会被编译成Java字节码，然后运行于JVM之上，并可以调用现有的Java类库，实现两种语言的无缝互操作的。
面向对象
Scala是一种面向对象的语言。
Scala中的每个值都是一个对象，包括基本数据类型（即布尔值、数字等）在内，连函数也是对象。
函数式编程
Scala也是一种函数式语言，其函数也能当成值来使用。
Scala中支持高阶函数，允许嵌套多层函数，并支持柯里化。
Scala提供了模式匹配，可以匹配各种情况，比如变量的类型、集合的元素、有值或无值。
静态类型
Scala具备类型系统，通过编译时检查，保证代码的安全性和一致性。
并发性
Scala使用Actor作为其并发模型，Actor是类似线程的实体。
Actor可以复用线程，因此可以在程序中使用数百万个Actor，而线程只能创建数千个。
1.3 为什么要学Scala
优雅：这是框架设计师第一个要考虑的问题，框架的用户是应用开发程序员，API是否优雅直接影响用户体验。
简洁：Scala语言表达能力强，一行代码抵得上Java多行，开发速度快。
融合大数据生态圈：Hadoop现在是大数据事实标准，(Kafka Spark源码都是用Scala编写的，Spark, Flink都支持使用Scala进行开发)Spark并不是要取代Hadoop，而是要完善Hadoop生态。
第2节 环境准备
Scala官网：https://www.scala-lang.org/
1、下载Scala
2、Windows下安装Scala
3、配置IDEA开发环境
4、REPL
2.1 Windows下环境配置
访问Scala官网下载Scala 2.11.8安装包，下载地址：https://www.scala-lang.org/download/2.11.8.html
下载scala-2.11.8.msi后，点击下一步就可以了（自动配置上环境变量）。
也可以下载 scala-2.11.8.zip，解压后配置上环境变量就可以了。
备注：安装Scala之前，Windows系统需要安装JDK。
2.2 IDEA环境配置
IDEA是 Java 的集成开发环境，要支持Scala开发，需要安装Scala插件；
/**
* @author CH
*/
object HelloWorld1 {
def main(args: Array[String]): Unit = {
println("Hello World")
}
}
2.3 Scala的REPL
在命令行输入Scala可启动Scala REPL。
REPL 是一个交互式解析器环境，R(read)、E(evaluate) 、P（print）、L（loop）
输入值，交互式解析器会读取输入内容并对它求值，再打印结果，并重复此过程。
第3节 基础语法
基础语法规则 (java)：
- 区分大小写 - Scala语言对大小写敏感；
- 类名 - 对于所有的类名的第一个字母要大写。如果需要使用几个单词来构成一个类名，每个单词的第一个字母要大写；比如:ListDemo
- 方法名 - 所有方法名的第一个字母用小写。如果需要使用几个单词来构成方法名，除第一个单词外每个词的第一个字母应大写；比如：getResult
- 程序文件名 - Scala程序文件的后缀名是 .scala，程序文件的名称可以不与对象名称完全匹配。这点与Java有所区别。建议遵循 Java 的惯例，程序文件名称与对象名称匹配；
- main()方法 - Scala程序从main()方法开始处理，这是每一个Scala程序的入口点。main()定义在object中；
标识符。所有Scala组件都需要名称，用于对象、类、变量和方法的名称称为标识符。
关键字不能用作标识符，标识符区分大小写；
标识符以字母或下划线开头，后面可以有更多的字母、数字或下划线；
$字符是Scala中的保留关键字，不能在标识符中使用；
注释。Scala使用了与Java相同的单行和多行注释；
换行符。Scala语句可以用分号作为一行的结束，语句末尾的分号通常可以省略，但是如果一行里有多个语句那么分号是必须的。
小结：
Scala的基础语法与Java比较类似，但是仍然有三点不一样的地方：
1、在Scala中换行符是可以省略的
2、Scala中main方法定义在object中
3、Scala中程序文件名可以不与对象名称相匹配，但是建议仍然遵循Java的规范，二者最好匹配
第4节 常用类型与字面量
Scala和Java一样，有8种数值类型 Byte、Short、Int、Long、Float、Double、Char、Boolean 类型；
和 Java 不同的是 ，这些类型都是类，有自己的属性和方法。
Scala并不刻意的区分基本类型和引用类型。
String 直接引用 Java.lang.String 中的类型，String在需要时能隐式转换为StringOps，因此不需要任何额外的转换，String就可以使用StringOps中的方法。
每一种数据类型都有对应的Rich类型，如RichInt、RichChar等，为基本类型提供了更多的有用操作。
-- StringOps。 //toInt等方法都定义在StringLike中；StringOps实现了StringLike "11".toInt
1.max(10)
1.min(10)
1.to(10)
1.until(10)
整数字面量。整数字面量有两种形式，十进制与十六进制(0X/0x开头)
-- 十六进制整数字面量
scala> val a = 0xa
a: Int = 10
scala> val a = 0X00FF
a: Int = 255
scala> val magic = 0xcafe
magic: Int = 51966
-- 十进制整数字面量
scala> val dec1 = 255
dec1: Int = 255
scala> val dec1 = 31
dec1: Int = 31
-- Long类型整数字面量
scala> val magic = 0xcafeL
magic: Long = 51966
scala> val long1 = 255L
long1: Long = 255
-- Short 或 Byte 类型，需要明确声明，否则编译器会推断为Int类型
scala> val little: Short = 32767
little: Short = 32767
scala> val littler: Byte = 127
littler: Byte = 127
浮点数字面量
-- 十进制数、可选的小数点、可选的e开头的指数
scala> val big = 3.1415926
big: Double = 3.1415926
scala> val bigger = 3.1415926e1
bigger: Double = 31.415926
-- 浮点数字面量以F/f结尾为Float类型；否则为Double类型；
scala> val litte = 0.31415926f
litte: Float = 0.31415927
scala> val litte = 0.31415926e1F
litte: Float = 3.1415925
字符字面量
scala> val a = 'A'
a: Char = A
-- 用字符的Unicode码来表示。Unicode码前128个字符就是ASCII码
scala> val b = '\u0042'
b: Char = B
-- 转义字符
scala> val mark = '\'
<console>:1: error: unclosed character literal
val mark = '\'
^
scala> val mark = '\\'
mark: Char = \
字符串字面量
scala> val str = "Hello Scala"
str: String = Hello Sca
第5节 类层次结构
Scala中，所有的类，包括值类型和引用类型，都最终继承自一个统一的根类型Any。
Scala中定义了以下三个底层类：
- Any是所有类型共同的根类型，Any是AnyRef和AnyVal的超类
- AnyRef是所有引用类型的超类
- AnyVal是所有值类型的超类(类比java的基本类型)
上图中有三个类型需要注意：
Null是所有引用类型的子类型
- Null类只有一个实例对象null。
- null可以赋值给任意引用类型，但是不能赋值给值类型。
Nothing位于Scala类继承关系的底部，它是其他所有其他类型的子类型
-
Nothing对泛型结构有用 。比如，空列表Nil的类型就是List[Nothing]
- Nothing的可以给出非正常终止的信号。比如，使用Nothing处理异常
Unit类型用来标识过程，过程就是没有返回值的方法，Unit类似于Java里的void。Unit只有一个实例()。
-- null 不能赋值给值类型
scala> val i: Int = null
<console>:11: error: an expression of type Null is ineligible for implicit
conversion
val i: Int = null
scala> val str: String = null
str: String = null
-- 使用 Nothing 处理异常
val test = false
val thing: Int = if (test) 42 else throw new Exception("ERROR!")
-- Unit类型只有一个实例()，该实例没有实际意义
scala> val a = ()
a: Unit = ()
第6节 值与变量&自动类型推断
Scala当中的声明变量可以使用以下两种方式：
- val，值 -- value，用val定义的变量，值是不可变的
- var，变量 -- variable，用var定义的变量，值是可变的
在Scala中，鼓励使用val。大多数程序并不需要那么多的var变量。
声明变量时，可以不指定变量的数据类型，编译器会根据赋值内容自动推断当前变量的数据类型。
备注：简单数据类型可以省略，对于复杂的数据类型建议明确声明；
声明变量时，可以将多个变量放在一起声明。
-- val定义的变量不可更改，变量的类型编译器可以进行自动类型推断
val name = "zhangsan"
-- 必要时可以指定数据类型
var name: String = null
-- 可以将多个值或变量放在一起声明
val x, y = 100;
var name, message: String = null
第7节 操作符
Scala的算术操作符、位操作符与 Java中的效果一样的。
需要特别注意一点：Scala中的操作符都是方法
a + b 等价 a.+(b)
1 to 10 等价 1.to(10)书写时推荐使用：a + b 、1 to 10这种代码风格。
Scala 没有提供 ++、-- 操作符，但是可以使用+=、-=
第8节 块表达式和赋值语句
{} 块包含一系列表达式，其结果也是一个表达式，块中最后一个表达式的值就是块的值。
赋值语句返回Unit类型，代表没有值；
package com.ch.part01
/**
* {}块表达式，可以包含一系列表达式，块中最后一个表达式的值就是整个块的值
*/
object BlockDemo {
def main(args: Array[String]): Unit = {
val x1 = 1
val y1 = 2
val x2 = 3
val y2 = 4
val distance = {
val dx = x2 - x1
val dy = y2 - y1
math.sqrt(dx * dx + dy * dy)
}
println(distance)
//赋值语句的值是Unit类型的, 下面等同于 x = {y = 1}
var y = 0
val x = y = 1
println(x)
}
}
第9节 输入和输出 Stdin.readLine (新)
通过readLine 从控制台读取一行输入。
如果要读取数字、Boolean或者字符，可以用readInt、readDouble、readByte、readShort、readLong、readFloat、readBoolean或者readChar。
print、println、printf 可以将结果输出到屏幕；
package com.ch.part01
object ReadLineAndPrintDemo {
def main(args: Array[String]): Unit = {
print("请输入您的姓名：")
val name=scala.io.StdIn.readLine()
print("请输入您的年龄：")
val age=scala.io.StdIn.readInt()
println("您的姓名是："+name+"，年龄："+age)
//printf是一个带有C语言风格的格式化字符串函数
printf("您的姓名是：%s，年龄：%d",name,age)
println()
println(s"您的姓名：$name,年龄：$age")
}
}
第10节 字符串插值器 (新)
Scala 提供了三种字符串插值器：
- s 插值器，对内嵌的每个表达式求值，对求值结果调用toString，替换掉字面量中的那些表达式
- f 插值器，它除s插值器的功能外，还能进行格式化输出，在变量后用%指定输出格式，使用java.util.Formatter中给出的语法
- raw 插值器，按照字符串原样进行输出
package com.ch.part01
/**
* Scala中的插值器
*/
object InterpolatorDemo {
def main(args: Array[String]): Unit = {
//s插值器，可以通过$获取变量和表达式的值
val subject = "Scala"
val message = s"Hello,$subject"
println(message)
val array: Array[Int] = (1 to 10).toArray
val str = s"array.length=${array.length}"
println(str)
println(s"${10 * 9}")
//f插值器，用%指定输出格式
val year=2020
val month=8
val day=9
println(s"$year-$month-$day")
//以yyyy-MM-dd的方式显示，不足2位用0填充
println(f"$year-$month%02d-$day%02d")
//raw插值器，将字符串按原样输出
println("a\n\tc")
println(raw"a\nb\tc")
println("""a\nb\tc""")
}
}
第11节 对象相等性
Java 中可以 == 来比较基本类型和引用类型：
- 对基本类型而言，比较的是值的相等性
- 对引用类型而言，比较的是引用相等性，即两个变量是否指向JVM堆上的同个对象
Scala中，要比较两个基础类型的对象是否相等，可以使用 == 或 !=；
== 或 != 可以比较相同类型或不同类型的两个对象；
== 或 != 还可以比较不同类型的两个对象：
package com.ch.part01
object ObjectCompareDemo {
def main(args: Array[String]): Unit = {
println(1==1)
println(1!=2)
println(1==2)
val flag=List(1,2,3)==List(4,5,6)
println(flag)
println(List(1,2,3)!=Array(1,2,3))
//比较不同类型的对象
println(2==2.0)
println(List(1,2,3)=="Scala")
}
}
第二部分 控制结构和函数
第1节 if 表达式 (新)
Scala中 if 表达式有返回值。
如果if 和 else 的返回值类型不一样，那么就返回两个返回值类型公共的父类。
package com.ch.part02
object IfDemo {
def main(args: Array[String]): Unit = {
// 在Scala中不需要添加分号作为语句块的结束符
val num = 20
// 在Scala中 if else语句是有返回值的，返回值就是最后一条语句的返回值
if (num > 20) "zhangsan" else "jacky"
//if语句可以嵌套
if (num < 20)
0
else if (num == 20)
1
else
-1
// 因为if else语句是有返回值的，所以可以直接将if else语句赋值给一个变量
// 注意：返回值不需加return关键字
// 下面等同于: val result = {if (num > 20) "zhangsan" else "jacky"}
val result = if (num > 20) "zhangsan" else "jacky"
// 如果if else语句中返回值的类型不一样，那么Scala会自动推断出两者的公共父类型，作为表达式的返回值类型
val result2: Any = if (num == 20) "jacky" else 100
println(result2)
// 如果if else语句中缺省了else语句块，那么默认else的值是Unit
// Unit用“()”来表示，类似于Java中的void
val result3 = if (num > 20) "jacky"
val result4 = if (num > 20) "jacky" else ()
}
}
第2节 for 表达式 (新)
Scala中，for循环语法结构：for (i <- 表达式 / 集合)，让变量 i遍历<-右边的表达式/集合的所有值。
Scala为for循环提供了很多的特性，这些特性被称之为 for守卫式 或 for推导式。
package com.ch.part02
/**
* Scala拥有与Java相同的While和do While循环
* 但是没有与Java for循环相对应的语法结构
* Scala中的for：for(i <- 表达式或集合)，让循环变量i遍历<-右达表达式或集合的所有值
* 注意：循环变量i前面没有用val 或 var来修饰，这个循环变量的类型是表达式或集合的元素类型
* 循环变量的作用域一直持续到循环结束
*/
object ForDemo {
def main(args: Array[String]): Unit = {
//for基本结构，使用to实现左右两边闭合的访问区间[1,10]
for (i <- 1 to 10) {
println(s"i = $i") // 1 ~ 10
}
//for基本结构，使用until实现左闭右开的访问区间[1,10)
for (i <- 1 until (10)) {
println(s"i = $i") // 1 ~ 9
}
//双重循环，相当于Java中的嵌套循环，条件之间用分号分隔
println("=============双重循环=================")
for (i <- 1 to 3; j <- 1 to 5) {
println(i * j) // 1*1 1*2 ... 1*5 ... 3*5
}
println("=============循环中使用变量=================")
for (i <- 1 to 3; j = 4 - i) {
println(i * j)
}
println("=============守卫式，循环中增加if条件语句=================")
//注意：if前面没有分号
// 等同于把 if 放在循环中
for (i <- 1 to 10; j <- 1 to 10 if i == j) {
println(s"i * j = $i * $j =${i * j}")
}
println("=============推导式，使用yield接收返回结果=================")
//如果for循环的循环体以yield开始，那么此循环会构造出一个集合，每次迭代生成集合中的一个值。
//可以使用变量接收产生的新集合
val result = for (i <- 1 to 5) yield i % 2
result.foreach(println(_)) // 1 0 1 0 1
println("=============九九乘法表=================")
for (i <- 1 to 9; j <- 1 to i) {
print(s"$j * $i = ${i * j}\t")
if (i == j) println()
}
println("=============for循环中使用大括号=================")
for {
i <- 1 to 3
from = 4 - i
j <- from to 3
}
println(s"i=$i,j=$j")
println("=============遍历字符串=================")
val message="sparkscala"
for(elem <- message) print(elem+" ") // s p a r k s c a l a
}
}
第3节 while 表达式 (新)
Scala提供了与 Java 类似的while和do...while循环。while语句的本身没有任何返回值类型，即while语句的返回结果是Unit类型的 () 。
Scala内置控制结构特地去掉了 break 和 continue。
特殊情况下如果需要终止循环，可以有以下三种方式：
- 使用Boolean类型的控制变量
- 使用return关键字
- 使用breakable和break，需要导入scala.util.control.Breaks包
package com.ch.part02
object WhileDemo {
def main(args: Array[String]): Unit = {
var num = 1
// while (num < 10) {
// println(s"num = $num")
// num += 1
// }
// do {
// println(s"num = $num")
// num += 1
// } while (num < 10)
//使用Boolean类型的控制变量，终止循环
// var flag = true
// while (flag) {
// println(s"num = $num")
// num += 1
// if(num==5) flag=false
// }
//使用return关键字终止循环
// for (i <- 1 to 10) {
// if (i == 5) return
// println(s"i=$i")
// }
//使用breakable和break终止循环，需要导入scala.util.control.Breaks包 ._ 代表全部内容
import scala.util.control.Breaks._
var res = 0
breakable {
for (i <- 1 until (10)) {
if (i == 5) break()
res += i
}
}
println(res)
}
}
第4节 函数 (新)
函数体中最后一句为返回值的话，可以将return 去掉；如果一个函数体只有一句代码，大括号可以去掉；
如果一个函数没有返回值，其返回类型为Unit , 并且 “=” 号可以去掉，这样的函数被称为过程；
可以不声明函数的返回类型，返回类型可通过自动类型推断来完成，但递归函数的返回类型必须声明；
备注：建议明确声明函数的返回值，即使为Unit
package com.ch.part02
object FunctionDemo {
/**
* 定义函数的语法结构：def 函数名(参数列表):返回值类型={函数体}
* 函数体中最后一条语句的返回值作为整个函数的返回值，返回值不需要使用return关键字
* 也可以不声明函数的返回值类型，Scala会自动根据最后一条语句的返回值推断出函数的返回值类型
* 但是，如果是递归函数，其返回值类型必须声明
*
* @param num1
* @param num2
* @return
*/
def add(num1: Int, num2: Int) = {
num1 + num2
}
// 通过递归的函数来计算阶乘
def factorial(num: Int): Long = {
if (num <= 1)
1
else
num * factorial(num - 1)
}
// 通过递归函数实现一个斐波那契数列：1,1,2,3,5,8.....
def fibonacci(n: Int): Long = {
if (n == 1 || n == 2) {
1
} else {
fibonacci(n - 1) + fibonacci(n - 2)
}
}
//如果函数没有返回值，其返回值类型为Unit，类似于Java中的void，“=”也可以省略
//在Scala中，没有返回值的函数称为过程
def getSum(x: Int, y: Int) {
println(x + y)
}
//函数中的参数可以有默认值，称为默认参数
def add2(x: Int = 10, y: Int = 20): Unit = {
x + y
}
//变长参数：参数类型右边加上*号
//变长参数只能出现在参数列表的尾部，并且只能有一个
//在Spark的源码中有大量的变长参数
def addSum(nums: Int*): Int = {
nums.sum
}
def main(args: Array[String]): Unit = {
println(add(1, 2))
println("计算阶乘：" + factorial(4))
println("斐波那契数列：" + fibonacci(6))
//调用函数时，使用函数中的参数的默认值
println(add2())
//调用函数时，给函数的参数重新赋值
println(add2(30, 40))
//在调用函数时，不按照函数定义的参数顺序来传递值，而是使用带名参数的方式来传值
println(add2(y = 60, x = 50))
println(addSum(1))
println(addSum(1, 2, 3))
println(addSum(1, 2, 3, 4, 5))
//使用 parameter:_*的形式，告诉编译器这个参数被当成参数序列处理 重要
println(addSum(1 to 10: _*))
}
}
第5节 懒值 (新)
当 val 被声明为lazy时(var不能声明为lazy)，它的初始化将被推迟，直到首次对此取值，适用于初始化开销较大的场景。
package com.ch.part02
/**
* 在Scala中提供了lazy的特性
* 如果将一个变量声明为lazy，那么只有第一次使用这个变量时，变量对应的表达式才会发生计算。
* 这种特性对于特别耗时的计算操作特别有用，
* 比如：初始化开销较大的场景，对文件进行IO、进行网络IO的操作等
*/
object LazyDemo {
def main(args: Array[String]): Unit = {
//使用lazy关键字之后，即使文件不存在，也不会报错
//只有第一次使用变量时才会报错
lazy val file1=scala.io.Source.fromFile("src/test.scala")
println("OK!")
// 加上下面的方法时才会报错
file1.getLines().size
}
}
第6节 文件操作 (新)
导入scala.io.Source后，可引用Source中的方法读取文本文件的内容
import scala.io.{BufferedSource, Source}
object FileDemo {
def main(args: Array[String]): Unit = {
//注意文件的编码格式，如果编码格式不对，那么读取报错
val file: BufferedSource = Source.fromFile("... ...", "GBK");
val lines: Iterator[String] = file.getLines()
for (line <- lines) {
println(line)
}
//注意关闭文件
file.close()
}
}
如果要将文件内容转数组，直接调用toArray。
读取网络资源
import scala.io.{BufferedSource, Source}
//读取网络资源，需要在联网状态下
def readNetSource: Unit = {
val source: BufferedSource = Source.fromURL("http://www.baidu.com")
val message: String = source.mkString
println(message)
source.close()
}
}
Scala没有内建的对写入文件的支持。要写入文本文件，可使用 java.io.PrintWriter
import java.io.PrintWriter
//写入文本文件
//Scala中没有内建的对写入文件的支持，需要使用java.io.PrintWriter来实现
def writeTextFile: Unit = {
val writer = new PrintWriter("src\\text.txt")
for (i <- 1 to 10) {
//写入文件内容
writer.println(s"i = $i")
//刷新printwriter流的缓冲区
writer.flush()
}
//关闭写入流
writer.close()
}
228
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
