Scala学习笔记
一、简介
scala是一门基于JVM的多范式编程语言
二、语法
1、语法格式
1.1 var val
定义变量
val/var 变量标识：变量类型 = 初始值
eg： var/val name:Sting = “Tom”1.2 使用类型推断来定义变量
Scala的语法要比Java简洁, 我们可以使用一种更简洁的方式来定义变量.
需求: 使用更简洁的语法定义一个变量, 保存一个人的名字"Tom"
scala> val name = "Tom"
name: String = Tom1.3 惰性赋值
当有一些变量保存的数据较大时, 但是不需要马上加载到JVM内存中, 就可以使用"惰性赋值"来提高效率.
语法格式:
lazy val/var 变量名 = 表达式2、字符串
2.1 双引号
val/var 变量名 = "字符串值"2.2 插值
//Scala中, 可以使用插值表达式来定义字符串, 能有效避免大量字符串的拼接.
val/var 变量名 = s"${变量/表达式}字符串"
注意:
a) 在定义字符串之前添加 s
b) 在字符串中, 可以使用${}来引用变量或者编写表达式. 2.3 三引号
如果有大段的文本需要保存, 就可以使用三引号来定义字符串. 例如: 保存一大段的SQL语句, 三引号中间的所有字符串都将作为字符串的值.
eg：val sql = """select
*
from
t_user
where
name = "zhangsan"
""" 3、数据类型与操作符
注意Scala类型与Java类型的不同:
1) Scala中所有的类型都使用"大写字母"开头.
2) 整形使用Int, 而不是Integer.
3) Scala中定义变量可以不写类型, 让Scala编译器自动推断.
注意:
1) Scala中没有++, --运算符
2) 与Java不一样, 在Scala中, 可以直接使用==, !=进行比较, 它们与equals方法表示一致. 而比较两个对象的引用值, 使用 eq 4、条件表达式（语法和java一样）
4.1 有返回值的if
与java不一样的是
在scala中，条件表达式也是有返回值的
在scala中，没有三元表达式，可以使用if表达式替代三元表达式
val result = if（sex == “male”）1 else 04.2 块表达式
在scala中，使用{}表示一个块表达式
和if表达式一样，块表达式也是有值的
值就是最后一个表达式的值
scala> val a = {
| println("1 + 1")
| 1 + 1
| }
返回值是2
scala> val a = {
| println("1 + 1")
| 1 + 1
| 3 + 4
| }
返回值是75、循环
5.1 for表达式
for(i <- 表达式/数组/集合) {
// 表达式
}
1.to(10) 1到10
嵌套循环
for(i <- 1 to 3;j <- 1 to 5){
//表达式
}
守卫(在for循环中加入了if)
for（i <- 表达式/数组/集合 if 表达式）{
// 表达式
}
eg：
// 添加守卫，打印能够整除3的数字
for(i <- 1 to 10 if i % 3 == 0) println(i)
for 推导式
将来可以使用for推导式生成一个集合
在for循环中，可以使用yield表达式构建出一个集合，我们把使用yield的表达式称为推导式
eg：生成一个10、20、30...100的集合
for(i <- 1 to 10) yield i * 105.2 while循环（必须是var的变量）
scala> while(i <= 10) {
| println(i)
| i = i+1
| }5.3 break和continue
实现break 在for循环外
导入break包 import scala.util.control.break
使用breakable将for表达式包起来
for表达式中需要退出循环的地方，添加`break()`方法调用
eg:
breakable{
for(i <- 1 to 100){
if(i >= 50) break()
else println(i)
}
}
实现continue 在for循环内
for(i <- 1 to 100){
breakable{
if(i % 10 == 0) break()
else println(i)
}
}
6、方法
6.1 定义方法
def methodname(类型名：参数类型，类型名：参数类型) ： [return type] = {
// 方法体
}
eg： 返回两个数的和
def sum(a:Int,b:Int) = a + b
注意：
- 参数列表的参数类型不能省略
- 返回值类型可以省略，由scala编译器自动推断
- 返回值可以不写return，默认就是{}块表达式的值
特别注意：
- 定义递归方法，不能省略返回值类型
eg:
def jc(i:Int) = {
if(i<=1) 1
else jc(i-1) * i
}
6.2 方法参数
- 默认参数
// x，y带有默认值为0
def add(x:Int = 0, y:Int = 0) = x + y
add()
- 带名参数 （在调用方法时，可以指定参数的名称来进行调用。）
def add(x:Int = 0, y:Int = 0) = x + y
add(1)
返回的是 1 第一个参数会被覆盖
add(y=1)
返回的是 1 第二个参数会被覆盖
- 变长参数 （如果方法的参数是不固定的，可以定义一个方法的参数是变长参数）
def 方法名(参数名：参数类型*) ：返回值类型 = {
方法体
}
eg：def add(num:Int*) = num.sum // 求和6.3 方法调用方式
- 后缀调用法
对象名.方法名(参数)
eg：Math.abs(-1)
- 中缀调用法
对象名 方法名 参数
eg：1 to 10 如果有多个参数，使用括号括起来
Math abs -1
- 花括号调用法 // 方法只有一个参数，才能使用花括号调用法
Math.abs{
// 表达式1
// 表达式2
}
eg：Math.abs{-10}
- 无括号调用法(如果方法没有参数，可以省略方法名后面的括号)
eg:
def m3()=println("hello")
m3()7、函数
7.1 定义函数
val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数体
> - 函数是一个**对象**（变量）
> - 类似于方法，函数也有输入参数和返回值
> - 函数定义不需要使用`def`定义
> - 无需指定返回值类型
7.2方法和函数的区别
- 方法是隶属于类或者对象的，在运行时，它是加载到JVM的方法区中
- 可以将函数对象赋值给一个变量，在运行时，它是加载到JVM的堆内存中
- 函数是一个对象，继承自FunctionN，函数对象有apply，curried，toString，tupled这些方法。方法则没有
- 方法无法复制给变量
7.3 方法转换为函数
- 有时候需要将方法转换为函数，作为变量传递，就需要将方法转换为函数
- 使用` _`即可将方法转换为函数
eg：
1. 定义一个方法用来进行两个数相加
2. 将该方法转换为一个函数，赋值给变量
def add(x:Int,y:Int)=x+y
add: (x: Int, y: Int)Int
scala> val a = add _
8、数组
8.1 定长数组（长度不可以改变，元素可以改变）
// 通过指定长度定义数组
val/var 变量名 = new Array[元素类型](数组长度)
// 用元素直接初始化数组
val/var 变量名 = Array(元素1, 元素2, 元素3...)
使用`()`来获取元素和改变元素的值
eg：变量名（下标）
获取长度
数组名.length8.2 变长数组
- 创建变长数组，需要提前导入ArrayBuffer类`import scala.collection.mutable.ArrayBuffer
- 创建空的ArrayBuffer变长数组，语法结构：
val/var a = ArrayBuffer[元素类型]()
- 创建带有初始元素的ArrayBuffer
val/var a = ArrayBuffer(元素1，元素2，元素3....)
- 添加修改删除元素
- 使用`+=`添加元素
数组名 += 元素
- 使用`-=`删除元素 同上
- 使用`++=`追加一个数组到变长数组
数组名 ++= Array(....)
8.3 遍历数组
- 使用`for表达式`直接遍历数组中的元素
for(i<- 数组名) println(i)
- 使用`索引`遍历数组中的元素
1、for(i <- 0 to a.length - 1) println(a(i))
2、for(i <- 0 until a.length) println(a(i))
0 until n——生成一系列的数字，包含0，不包含n
0 to n ——包含0，也包含n8.4 数组中的常用算法
- 求和——sum方法
- 求最大值——max方法
- 求最小值——min方法
- 排序——sorted方法 升序
用法：
数组名.方法名 a.sum9、元组 （元素是不可变的）
9.1定义元组
- 元组可以用来包含一组不同类型的值。例如：姓名，年龄，性别，出生年月。元组的元素是不可变的。
- 使用括号来定义元组
val/var 元组 = (元素1, 元素2, 元素3....)
- 使用箭头来定义元组（元组只有两个元素）
val/var 元组 = 元素1->元素2
scala> val a = ("zhangsan", 20)
a: (String, Int) = (zhangsan,20)
scala> val a = "zhangsan" -> 20
a: (String, Int) = (zhangsan,20)
9.2 访问元组
使用_1、_2、_3....来访问元组中的元素，_1表示访问第一个元素，依次类推
eg：
val a = "zhangsan" -> "male"
获取第一个元素
a._110、列表（可以保存重复的值，有先后顺序）
10.1 不可变列表
val/var 变量名 = List(元素1, 元素2, 元素3...)10.2 可变列表
可变列表就是列表的元素、长度都是可变的。
要使用可变列表，先要导入`import scala.collection.mutable.ListBuffer`
使用ListBuffer\[元素类型\]()创建空的可变列表，语法结构：
val/var 变量名 = ListBuffer[Int]()
使用ListBuffer(元素1, 元素2, 元素3...)创建可变列表，语法结构：
val/var 变量名 = ListBuffer(元素1，元素2，元素3...)10.3 可变列表的操作
- 获取元素（使用括号访问`(索引值)`）
a.(0)
- 添加元素（`+=`）
a += 元素
- 追加一个列表（`++=`）
a ++= List(...)
- 更改元素（`使用括号获取元素，然后进行赋值`）
- 删除元素（`-=`）
a -= 元素
- 转换为List（`toList`）
a.toList
- 转换为Array（`toArray`）
a.toArray10.4 列表常用操作
- 判断列表是否为空（`isEmpty`） 返回 boolean类型的值
- 拼接两个列表（`++`）
列表1 ++ 列表2
- 获取列表的首个元素（`head`）和剩余部分(`tail`)
- 反转列表（`reverse`）
- 获取前缀（`take`）、获取后缀（`drop`）
a.take(3) 返回前三个值
a.drop(3) 返回除了前三个值以外的值
- 扁平化（`flaten`）
扁平化表示将列表中的列表中的所有元素放到一个列表中。
eg：
- 有一个列表，列表中又包含三个列表，分别为：List(1,2)、List(3)、List(4,5)
- 使用flatten将这个列表转换为List(1,2,3,4,5)
- 拉链（`zip`）和拉开（`unzip`）
- 拉链：使用zip将两个列表，组合成一个元素为元组的列表
- 拉开：将一个包含元组的列表，解开成包含两个列表的元组
eg：
val a = List("zhangsan", "lisi", "wangwu")
val b = List(19, 20, 21)
scala> a.zip(b)
List[(String, Int)] = List((zhangsan,19), (lisi,20), (wangwu,21))
- 转换字符串（`toString`）
toString方法可以返回List中的所有元素
- 生成字符串（`mkString`）
val a = List(1,2,3,4)
a.mkString
String = 1234
a.mkString(":")
String = 1:2:3:4
以下三个的用法：列表名1.方法名(列表名2)
- 并集（`union`）
- 交集（`intersect`）
- 差集（`diff`）11、Set（元素不重复 ，不保证插入顺序 ）
11.1 不可变集
创建一个空的不可变集，语法格式：
val/var 变量名 = Set[类型]()
给定元素来创建一个不可变集，语法格式：
val/var 变量名 = Set(元素1, 元素2, 元素3...)
基本操作
- 获取集的大小（`size`）
- 遍历集（`和遍历数组一致`）
- 删除一个元素，生成一个Set（`-`）
- 拼接两个集，生成一个Set（`++`）
- 拼接集和列表，生成一个Set（`++`）11.2 可变集
import scala.collection.mutable.Set
val a = Set(...)
// 添加元素 +=
// 删除元素 -=12、映射（由键值对组成的集合 ）
12.1 不可变
val/var map = Map(键->值, 键->值, 键->值...) // 推荐，可读性更好
val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)
- 根据key获取value
map("key")12.2 可变 Map
定义语法与不可变Map一致。但定义可变Map需要手动导入`import scala.collection.mutable.Map12.3 基本操作
- 获取值(`map(key)`)
- 获取所有key（`map.keys`）
- 获取所有value（`map.values`）
- 遍历map集合
for((x,y) <- map) println(s"$x $y")
- getOrElse
- 增加key,value对 '+'
map + key->value
- 删除key '-'
map - key13、函数式编程
- 遍历（`foreach`）
foreach(f: (A) ⇒ Unit): Unit
eg:
val a = List(1,2,3,4)
a.foreach((x:Int)=>println(x))
优化：a.foreach(x=>println(x))
优化：a.foreach(println(_)) 当函数参数，只在函数体中出现一次，而且函数体没有嵌套调用时，可以使用下划线来简化函数定义
- 映射（`map`） 就是一个将一种数据类型转换为另外一种数据类型的过程。
def map[B](f: (A) ⇒ B): TraversableOnce[B]
eg：
a.map(x=>x+1)
优化：a.map(_ + 1)
- 映射扁平化（`flatmap`） 理解为先map，然后再flatten
def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B]
// 定义文本行列表
scala> val a = List("hadoop hive spark flink flume", "kudu hbase sqoop storm")
a: List[String] = List(hadoop hive spark flink flume, kudu hbase sqoop storm)
// 使用map将文本行转换为单词数组
scala> a.map(x=>x.split(" "))
res5: List[Array[String]] = List(Array(hadoop, hive, spark, flink, flume), Array(kudu, hbase, sqoop, storm))
// 扁平化，将数组中的
scala> a.map(x=>x.split(" ")).flatten
res6: List[String] = List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)
- 过滤（`filter`）
- 是否存在（`exists`）
- 排序（`sorted`、`sortBy`、`sortWith`）
- 分组（`groupBy`）
- 聚合计算（`reduce`）
- 折叠（`fold`）
三、类和对象
1、定义和访问成员变量
- 创建类
class 对象名(){} // 如果类是空的 没有任何成员，可以省略{}
// 如果构造器的参数是空的，可以省略()
- 创建对象
val 对象名 = new 类名() // 创建对象可以省略括号
- 定义成员变量
1、完整的写法
var 变量名：类型 = 初始值 var name:String = “”
2、使用下划线来初始化成员变量
var 变量名：类型 = _ var name:String = _
3、可以省略类型，但是要赋值不能配合下划线使用
var name = “”
- 调用成员变量
对象名.成员变量
- 成员变量赋值
对象名.成员变量 = 值
- 定义成员方法
def 方法名（参数列表）={
方法体
}
- 调用成员方法
对象名.方法2、访问修饰符
可以在成员前面添加private/protected关键字来控制成员的可见性。但在scala中，**`没有public关键字`**，任何没有被标为private或protected的成员都是公共的3、类构造器（当创建类对象的时候，会自动调用类的构造器）
3.1主构造器
- 定义语法
class 类名(var/val 参数名：类型 = 默认值，var/val 参数名：类型 = 默认值){
// 构造代码块
}
- 注意
1、构造器的参数列表是直接定义在类名后面，添加了val/var表示直接通过主构造器定义成员变量
2、构造器参数列表可以指定默认值
3、创建实例，调用构造器可以指定字段进行初始化
4、整个class中除了**字段定义** 和 **方法定义**的代码都是构造代码
eg：
1、给构造器传入参数 val zhangsan = new Person("张三", 20)
2、不传入任何参数 val empty = new Person
3、指定字段进行初始化 val man40 = new Person(age = 40)3.2 辅助构造器（除了主构造器之外的构造器称为辅助构造器）
- 语法格式
定义辅助构造器与定义方法一样，也使用`def`关键字来定义
定义在主构造器里面
这个方法的名字为`this
def this(参数名:类型, 参数名:类型) {
// 第一行需要调用主构造器或者其他构造器
// 构造器代码
}
class Customer(var name: String = "", var address: String = "") {
def this(arr: Array[String]) = {
this(arr(0), arr(1))
}
}
def main(args: Array[String]): Unit = {
val zhansan = new Customer(Array("zhansan","beijing "))
println(zhansan.name)
println(zhansan.address)
}4、单例对象
4.1 定义单例对象
- 定义单例对象和定义类很像，就是把class换成object
- 在object中定义的成员变量类似于Java的静态变量
- 可以使用object直接引用成员变量
object Demo {
// 定义一个单例对象
object Student {
// 定义腿的数量
val STUDENT_NUM = 67 变量的名字大写 这是规范
}
def main(args: Array[String]): Unit = {
println(Student .STUDENT_NUM )
}
}4.2 定义成员方法
- 在object中定义的成员方法类似于Java的静态方法
object Demo {
object PrintUtil {
// 打印分割线
def printSpliter() = {
// 字符串乘法，表示返回多少个字符串
println("-" * 10)
}
}
def main(args: Array[String]): Unit = {
PrintUtil.printSpliter()
}
}5. 伴生对象
5.1 定义伴生对象
- 伴生对象必须要和伴生类一样的名字
- 伴生对象和伴生类在同一个scala源文件中
- 伴生对象和伴生类可以互相访问private属性
- 如果某个成员的权限设置为private[this]，表示只能在当前类中访问。伴生对象也不可以访问
- 定义伴生对象就是把定义类的class换成object
// 伴生类
class CustomerService {
}
// CustomerService的伴生对象
object CustomerService {
}5.2 apply方法
- 格式
object 伴生对象名 {
def apply(参数名:参数类型, 参数名:参数类型...) = new 类(...)
}6、继承
6.1语法
class/object 子类 extends 父类 {
}6.2 override和super
- 子类要覆盖父类中的一个方法，必须要使用override关键字
- 使用override来重写一个val字段
- 使用super关键字来访问父类的成员方法7、类型判断
- isInstanceOf判断对象是否为指定类以及其子类的对象
- asInstanceOf将对象转换为指定类型
// 判断对象是否为指定类型
val trueOrFalse:Boolean = 对象.isInstanceOf[类型]
// 将对象转换为指定类型
val 变量 = 对象.asInstanceOf[类型]8、抽象类
- 情况：
1. 方法没有方法体（**抽象方法**）
2. 变量没有初始化（**抽象字段**）
- 语法
// 定义抽象类
abstract class 抽象类名 {
// 定义抽象字段
val 抽象字段名:类型
// 定义抽象方法
def 方法名(参数:参数类型,参数:参数类型...):返回类型
}
9、特质(trait)
9.1 定义
scala中没有Java中的接口（interface），替代的概念是——特质
- 定义
trait 名称 {
// 抽象字段
// 抽象方法
}
- 继承特质
class 类 extends 特质1 with 特质2 {
// 字段实现
// 方法实现
}
9.2 对象混入trait
scala中可以将trait混入到对象中，就是将trait中定义的方法、字段添加到一个对象中
-- 定义
val/var 对象名 = new 类 with 特质
trait Logger {
def log(msg:String) = println(msg)
}
class UserService
def main(args: Array[String]): Unit = {
val service = new UserService with Logger
service.log("混入的方法")
}
9.3 trait调用链
类继承了多个trait后，可以依次调用多个trait中的同一个方法，只要让多个trait中的同一个方法在最后都依次执行super关键字即可。类中调用多个tait中都有这个方法时，首先会从最右边的trait方法开始执行，然后依次往左执行，形成一个调用链条。9.4 trait的构造机制
- trait也有构造代码，但和类不一样，特质不能有构造器参数
- 每个特质只有一个无参数的构造器。
- 一个类继承另一个类、以及多个trait，当创建该类的实例时，它的构造顺序如下：
1. 执行父类的构造器
2. `从左到右`依次执行trait的构造器
3. 如果trait有父trait，先构造父trait，如果多个trait有同样的父trait，则只初始化一次
4. 执行子类构造器
