1. Scala 安装
Scala 运行于Java平台（JVM，Java 虚拟机）上，并兼容现有的Java程序，Scala代码可以调用Java方法，访问Java字段，继承Java类和实现Java接口。在面向对象方面，Scala是一门非常纯粹的面向对象编程语言，也就是说，在Scala中，每个值都是对象，每个操作都是方法调用，有如下优点：
- 强大并发性、支持函数式编程（简单），可更好支持分布式系统
- 语法简洁，可提供优雅
API - 兼容
Java，运行速度快，可融合到Hadoop生态圈
Hello World
// 主函数名与文件名可不一致，区别于 Java
object HelloWorld {
def main(args: Array[String]): Unit = {
println("Hello World!")
}
}
参考文章：IDEA中配置Scala开发编译环境
2. 基础
2.1 基本操作
- 变量：双引号
- 语句后面可以没有分号
- 注释：
//、/* */ - 终端退出
scala shell环境：scala> :quit
2.2 变量
两种类型变量：
- 可变
var：声明后可再赋值 - 不可变
val：声明时必须初始化值，一旦声明不能赋值
val 不可变变量
scala> val name = "rose"
name: String = rose
// 重新赋值报错
scala> name="lila"
<console>:12: error: reassignment to val
name="lila"
^
// 显示指定数据类型
scala> val name:String = "lila"
name: String = lila
scala> val name:java.lang.String = "john"
name: String = john
scala> println(name)
john
注意：
Scala在声明变量时可不显示地指定变量类型，它可根据值反推数据类型，也可以显示指定变量类型！Scala的数据类型由import java.lang._包提供，每个程序会隐士地导入所有，所以可以不用再导入
var 可变变量
scala> var age = 19
age: Int = 19
scala> age = 18
age: Int = 18
2.3 基本数据类型
基本数据类型包括：Byte、Char、Short、Int、Long、Float、Double 和 Boolean，这些数据类型每个都是一个 Scala 包，如：Int 是 scala.Int。
字面量
字面量包括整数字面量、浮点数字面量、布尔型字面量、字符字面量、字符串字面量、符号字面量、函数字面量和元组字面量：
scala> val a = 123 // 整数字面量
a: Int = 123
scala> var a = 1.23 // 浮点数字面量
a: Double = 1.23
scala> var a = true // 布尔字面量
a: Boolean = true
scala> var a = "ABC" // 字符串字面量
a: String = ABC
scala> var a = "A" // 字符字面量
a: String = A
Scala 可对字面量直接调用方法，如：
// 整数字面量转换为字符串
scala> 8.toString()
res1: String = 8
// 获取两个字符串都有的字符
scala> "abc".intersect("bcd")
res2: String = bc
操作符
Scala 的支持的操作符包括：加(+)、减(-) 、乘(*) 、除(/) 、余数（%）等，使用格式：
// 两者等价
a 操作符 b
(a). 操作符 (b)
示例：
// 实际内部调用的就是 (5).+(3)
scala> 5 + 3
res3: Int = 8
scala> (5).+(3)
res4: Int = 8
// 递增、递减，区别于 Java 的 ++ --
scala> var age = 18
age: Int = 18
scala> age -= 1
scala> age
res6: Int = 17
2.4 Range
Range 支持创建不同数据类型的数值序列，包括 Int、Long、Float、Double、Char、BigInt和BigDecimal等，一般与 for 循环配合使用：
// 生成一个 1 到 5 的整数序列，包括 5，步长默认为 1
scala> 1 to 5
res7: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)
scala> 1.to(5)
res8: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)
// 生成一个 1 到 5 的整数序列，不包括 5
scala> 1 until 5
res9: scala.collection.immutable.Range = Range(1, 2, 3, 4)
// 指定步长
scala> 1 to 22 by 2
res10: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21)
scala> 0.5f to 5.9f by 0.8f
res11: scala.collection.immutable.NumericRange[Float] = NumericRange(0.5, 1.3, 2.1, 2.8999999, 3.6999998, 4.5, 5.3)
2.5 控制台输入输出
scala> val name = "rose"
name: String = rose
// 换行输出
scala> println(name)
rose
// 不换行输出
scala> print(name)
rose
scala> val age = 18
age: Int = 18
// 字符串格式化
scala> printf("My name's %s age: %d.", name, age)
My name's rose，age: 18.
控制台读写数据
读写方法：readInt、readDouble、readByte、readShort、readFloat、readLong、readChar、readBoolean、readLine，分别对应 9 中不同数据类型，前 8 种没参数，readLine 可不提供参数，也可以带一个字符串参数的提示：
这些方法都属于对象 scala.io.StdIn，使用前必须导入，在控制台输入数据不会显示（回车后才会显示）：
scala> import io.StdIn._
import io.StdIn._
scala> var i = readInt()
i: Int = 54
scala> var f=readFloat()
f: Float = 52.2
scala> var b= readBoolean()
b: Boolean = true
scala> var info = readLine("please input your name: ")
please input your name: info: String = rose
scala> info
res15: String = rose
2.6 读写文件
写文件
scala> import java.io.PrintWriter
import java.io.PrintWriter
scala> val out = new PrintWriter("C:\Users\hj\Desktop\scala.txt")
out: java.io.PrintWriter = java.io.PrintWriter@34604b32
scala> for(i <- 1 to 5) out.println(i)
scala> out.close()
读文件
scala> import scala.io.Source
import scala.io.Source
scala> val inputFile = Source.fromFile("C:\Users\hj\Desktop\scala.txt")
inputFile: scala.io.BufferedSource = non-empty iterator
scala> val lines = inputFile.getLines
lines: Iterator[String] = non-empty iterator
scala> for (line <- lines) println(line)
1
2
3
4
5
scala> inputFile.close()
IDEA 中使用
import scala.io.Source
import java.io.PrintWriter
object ReadWriteFile {
def main(args: Array[String]): Unit = {
readFile()
writeFile()
}
def readFile(): Unit = {
val inputFile = Source.fromFile("C:\\Users\\hj\\Desktop\\scala.txt")
val lines = inputFile.getLines()
for (line <- lines) {
println(line)
}
inputFile.close()
}
def writeFile(): Unit = {
val out = new PrintWriter("C:\\Users\\hj\\Desktop\\scala.txt")
for (i <- 1 to 10 by 2) {
out.println(i)
}
out.close()
}
}
2.7 异常处理
import java.io.{FileNotFoundException, FileReader, IOException}
object TryCatch {
def main(args: Array[String]): Unit = {
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException =>
println("文件不存在！", ex)
case ex: IOException =>
println("IO 错误操作", ex)
} finally {
println("Exiting finally...")
}
}
}
(文件不存在！,java.io.FileNotFoundException: input.txt (系统找不到指定的文件。))
Exiting finally...
3. 控制结构
3.1 if 条件表达式
object LoopTest {
def main(args: Array[String]): Unit = {
val score = 99
if (score > 80) {
println("A")
} else if (score < 80 && score > 70) {
println("B")
}else {
println("C")
}
}
}
if 条件表达的值可赋值给变量
scala> val x = 8
x: Int = 8
scala> val y = if (x>0) 1 else -1
y: Int = 1
3.2 while 循环
object LoopTest {
def main(args: Array[String]): Unit = {
test_while()
}
def test_while(): Unit = {
var i = 15
while (i <= 30) {
i += 1
}
println(i)
var m = 10
do {
m += 1
} while (m < 31)
println(m)
}
}
3.3 for 循环
格式：
// 变量<-表达式 部分被称为生成器
for (变量<-表达式) 语句块
scala> for (i <- 1 to 6) println(i)
1
2
3
4
5
6
// 设置步长为 2
scala> for (i <- 1 to 6 by 2) println(i)
1
3
5
// 设置守卫，满足条件才能返回
scala> for (i <- 1 to 6 by 3 if i%2==0) println(i)
4
多生成器
类似于多个 for 循环
scala> for (i <- 1 to 3; j <- 2 to 5) println(i*j)
2
3
4
5
4
6
8
10
6
9
12
15
守卫：
scala> for (i <- 1 to 3 if i==2; j <- 2 to 5 if j==3) println(i*j)
6
for 推导式
通过 for 循环遍历一个或多个集合，对集合中的元素进行 推导，从而计算得到新的集合，用于后续处理：
object LoopTest {
def main(args: Array[String]): Unit = {
test_for()
}
def test_for(): Unit ={
var abc = for (i <- 1 to 5 if i%2==0) yield i
for (a <- abc) {
println(a)
}
}
}
abc 是变量，yield 会将结果存储到集合中，循环结束后将返回该集合：
2
4
4. 数据结构
常用数据结构：
- 容器
Collection - 列表
LIst - 集合
Set - 映射
Map - 迭代器
Iterator - 数组
Array - 元组
Tuple
4.1 容器
Scala 有一套丰富的容器库，包括：列表、数组、集合、映射等，根据元素组织方式和操作方式，可分为：有序和无序、可变和不可变等不同容器类别，容器的三个类：
scala.collection、scala.collection.mutable、scala.collection.immutable
4.2 列表
列表是一种共享相同类型的不可变的对象序列，一旦定义值不能改变，声明时必须初始化值：
// 因为是不可变集合，索引列表存在 scala.collection.immutable 中
scala> import scala.collection.immutable
import scala.collection.immutable
scala> var strList = List("A", "B", "C")
strList: List[String] = List(A, B, C)
// 获取第一个元素
scala> strList.head
res1: String = A
// 获取除第一个元素后的所有元素集合（新的列表）
scala> strList.tail
res2: List[String] = List(B, C)
构造列表
使用格式：
// 在已有列表前端增加元素
元素::列表
// 将元素 D 添加到新列表 a_list 中
scala> val a_list = "D"::strList
a_list: List[String] = List(D, A, B, C)
// 生成一个新的列表 a_list
scala> a_list
res3: List[String] = List(D, A, B, C)
// 原列表保持不变
scala> strList
res4: List[String] = List(A, B, C)
Nil 空列表对象
scala> val b = 1::2::3::Nil
b: List[Int] = List(1, 2, 3)
// 效果与 List(1, 2, 3) 等同
4.3 集合
集合的元素不重复，无序，以 哈希 方式来组织元素，包括：
- 可变集合：
scala.collection.mutable - 不可变集合：
scala.collection.immutable，缺省情况下创建的是不可变集合，通常使用不可变集合
不可变集合
// 不能使用 val
scala> var set1 = Set("Hadoop", "Scala")
set1: scala.collection.immutable.Set[String] = Set(Hadoop, Scala)
scala> set1 += "Spark"
scala> set1
res6: scala.collection.immutable.Set[String] = Set(Hadoop, Scala, Spark)
scala> set1.contains("Scala")
res7: Boolean = true
可变集合
// 必须先引入 scala.collection.mutable.Set
scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set
scala> val set2 = Set("A", "B")
set2: scala.collection.mutable.Set[String] = Set(B, A)
scala> set2 += "C"
res8: set2.type = Set(B, C, A)
注意：对不可变集进行操作，会产生一个新的集合，原来的集合并不会发生变化。 而对可变集进行操作，改变的是该集合本身
4.4 映射
映射是一系列键值对的集合，类似于字典，键唯一，值不唯一，分为可变和不可变映射，同样地创建可变映射需要引入 scala.collection.mutable.Map 包
不可变映射
scala> val map1 = Map("name" -> "rose", "age" -> 18)
map1: scala.collection.immutable.Map[String,Any] = Map(name -> rose, age -> 18)
// 取值
scala> map1("name")
res10: Any = rose
scala> println(map1("name"))
rose
// 判断是否包含某个键
scala> map1.contains("age")
res12: Boolean = true
注意：不可变映射，是无法更新映射中的元素的，也无法增加新的元素。如果要更新映射的元素，就需要定义一个可变的映射
可变映射
scala> import scala.collection.mutable.Map
import scala.collection.mutable.Map
scala> val map2 = Map("name" -> "rose", "sex" -> "female")
map2: scala.collection.mutable.Map[String,String] = Map(name -> rose, sex -> female)
// 获取元素
scala> map2("sex")
res0: String = female
// 添加新的元素，不是同一类型添加失败
scala> map2("age") = 18
<console>:14: error: type mismatch;
found : Int(18)
* required: String
map2("age") = 18
^
scala> map2("age") = "18"
scala> map2
res3: scala.collection.mutable.Map[String,String] = Map(age -> 18, name -> rose, sex -> female)
// 添加新的映射（可一次添加多个）
scala> map2 += ("score" -> 98)
<console>:14: error: type mismatch;
found : Int(98)
required: String
map2 += ("score" -> 98)
^
scala> map2 += ("score" -> "98")
res5: map2.type = Map(age -> 18, name -> rose, sex -> female, score -> 98)
// 重新赋值
scala> map2("name") = "lila"
scala> map2
res7: scala.collection.mutable.Map[String,String] = Map(age -> 18, name -> lila, sex -> female, score -> 98)
循环遍历映射
scala> for ((k, v) <- map1) println(k, v)
(name,rose)
(age,18)
scala> for (k <- map1.keys) println(k)
name
age
scala> for (k <- map1.values) println(k)
rose
18
4.5 数组
数组是一种可变的、可索引的、元素具有相同类型的数据集合，可以通过显示指定类型或者隐式推断实例化一个数组，包含：
- 定长数组：长度不变的数组
- 变长数组：长度可变
定长数组
// 定义一个长度为 3 的 Int 类型数组
scala> val intArr = new Array[Int](3)
intArr: Array[Int] = Array(0, 0, 0)
// 赋值
scala> intArr(0) = 1
scala> intArr(1) = 2
scala> intArr(2) = 3
scala> intArr
res3: Array[Int] = Array(1, 2, 3)
// 定义一个长度为 3 的 String 类型数组
scala> val strArr = new Array[String](3)
strArr: Array[String] = Array(null, null, null)
scala> strArr(0) = "name"
scala> strArr
res5: Array[String] = Array(name, null, null)
// 不指定数据类型
scala> val intArr2 = Array(1, 2, 3)
intArr2: Array[Int] = Array(1, 2, 3)
多维数组
// 定义个二维数组，三行四列
scala> val a1 = Array.ofDim[Int](3, 4)
a1: Array[Array[Int]] = Array(Array(0, 0, 0, 0), Array(0, 0, 0, 0), Array(0, 0, 0, 0))
scala> a1(0)(0) = 1
scala> a1(0)(2) = 2
scala> a1(0)(1) = 3
scala> a1
res9: Array[Array[Int]] = Array(Array(1, 3, 2, 0), Array(0, 0, 0, 0), Array(0, 0, 0, 0))
// 定义一个三维数组
scala> val a2= Array.ofDim[String](3, 2, 4)
a2: Array[Array[Array[String]]] = Array(Array(Array(null, null, null, null), Array(null, null, null, null)), A
rray(Array(null, null, null, null), Array(null, null, null, null)), Array(Array(null, null, null, null), Array
(null, null, null, null)))
可变长数组
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
scala> val a3 = ArrayBuffer(10, 20, 30)
a3: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 20, 30)
scala> a3 += 40
res10: a3.type = ArrayBuffer(10, 20, 30, 40)
// 在索引 2 的位置添加 60、80
scala> a3.insert(2, 60, 80)
scala> a3
res12: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 20, 60, 80, 30, 40)
// 移除 40
scala> a3 -= 40
res13: a3.type = ArrayBuffer(10, 20, 60, 80, 30)
scala> val a4 = a3.remove(2)
a4: Int = 60
// remove 不改变原数组
scala> a3
res14: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 20, 80, 30)
4.6 元组
元组与列表不同之处在于，元组（索引从 1 开始）可以是不同数据类型，列表必须是相同数据类型：
scala> val t1 = ("a", "b", "c", 1, 1.2)
t1: (String, String, String, Int, Double) = (a,b,c,1,1.2)
scala> println(t1._1)
a
scala> println(t1._2)
b
scala> println(t1._3)
c
4.7 迭代器
Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，它有两个方法：
hasNext：检测是否有下一个元素next()：获取下一个元素
scala> val iter1 = Iterator("A", "B", "C")
iter1: Iterator[String] = non-empty iterator
scala> while (iter1.hasNext) {println(iter1.next())}
A
B
C
scala> val iter2 = Iterator("A", "B", "C", "D")
iter2: Iterator[String] = non-empty iterator
// iter1 已经没有元素，所有没有输出
scala> for (elem <- iter1) {println(elem)}
scala> iter1
res25: Iterator[String] = empty iterator
scala> for (elem <- iter2) {println(elem)}
A
B
C
Dcala>
grouped、sliding 方法
grouped：返回元素的增量分块，有点类似于切片sliding：生成一个滑动元素的窗口
scala> val xs = List(1, 2, 3, 4, 5)
xs: List[Int] = List(1, 2, 3, 4, 5)
scala> val a = xs grouped 3
a: Iterator[List[Int]] = non-empty iterator
// 一次获取三个元素
scala> a.next()
res0: List[Int] = List(1, 2, 3)
// 如果后面元素不足 3 个，有几个就返回几个
scala> a.next()
res1: List[Int] = List(4, 5)
// 一次获取三个元素，每调用一次 next()，就往后移动一位
scala> val b = xs sliding 3
b: Iterator[List[Int]] = non-empty iterator
scala> b.next()
res2: List[Int] = List(1, 2, 3)
scala> b.next()
res3: List[Int] = List(2, 3, 4)
scala> b.next()
res4: List[Int] = List(3, 4, 5)
其他方法
scala> val xs = List(1, 2, 3, 4, 5)
xs.size // 获取元素个数
xs.length // 获取迭代器长度
xs.toString() // 将迭代器转换为字符串