Scala语言学习

基础

安装Scala
REPL(Read-Evaluate-Print-Loop shell)
处理数据
- 字面量：直接出现在源代码中的数据
- 值value：val <identifier>[: <type>] = <data>
  - 不可变的、有类型的存储单元，支持类型推导
- 变量variable：var <identifier>[: <type>] = <data>
  - 可变的、有类型的存储单元，支持类型推导
  - 可重新赋值，但是不可改变数据类型（支持类型转换的例外）
- 命名：支持使用字母、数字和一些特殊的操作符字符
  - 例如可以使用 $*、：、+、\pi、\phi$ 等，不能使用[]和.
  - 合法命名规则
    - 不以数字开头
      - 以数字开头的话，编译器最初会把解析到的第一个数字当成一个字面量数字，然后后面解析到其他非数字字符就会出错
    - 一个或多个除反引用号外的任意字符，这些字符必须包围在一对反引号之中
```
val `a.b` = 4
```
类型
- 核心数值类型
  - Byte、Short、Int、Long、Float、Double
  - toType方法手动完成类型间转换
  - 与JVM包装数值类型可以互操作
- 字符串String
  - 建立在Java的String基础上
  - 与Java不同，==会检查字符串真正的想等性，而不是对象引用想等性
  - 三重引号创建多行String，类似Python """ your string """
  - 字符串内插
    - 在字符串的第一个双引号前面增加一个s前缀，使用美元符$指示插入数据的引用(某些容易区分的情况下，大括号{}可以省略，但是加上更容易区分)
```
val approx = 355/113f
println(s"Pi, using 355/133, is about ${approx}.")
```
  - 字符串内插的替代格式可以使用printf语法（java.util.Formatter）
    - 在字符串前面添加f前缀
```
scala> val item = "apple"
scala> f"Enjoying this $item ${355/133.0}%.5f times today.")
```
  - 正则表达式（基于Java类java.util.regex.Pattern）
    - 用正则表达式捕获值val <Regex value>(<identifier>) = <input string>)
    - val pattern = """.* apple ([\d.]+) times .*""".r
    - val pattern(amountText) = input
    - val amount = amountText.toDouble
- Scala类型概述
  
  Scala类型概述
  - Nothing：所有类型的子类
  - Null：所有指示null值的AnyRef类型的子类
  - Unit：指示没有值（类似void）
  - Any：Scala中所有类型的根
  - AnyVal：所有值类型的根
  - AnyRef：所有引用（非值）类型的根
- Scala不支持其他类型到Boolean类型的自动转换。非null字符串不会计算为true
- 元组 (<value 1>,<value 2>[,<value 3>...])
  - 不同于列表和数组，没有办法迭代处理一个元组中的元素，元组的作用只是作为多个值的容器
  - 根据元素的索引访问元组中的元素（下划线加上索引，索引从1开始）
  - 创建一个大小为2的元组，也可以使用关系操作符（->），表示元组中的键值对

表达式和条件式

表达式块（用{}结合多个表达式创建，最后一个表达式作为表达式块的返回值）
- 可嵌套、跨行，多个表达式写在一行需要;分隔
语句：不返回值的表达式
if...else表达式块
- if (<Boolean expression>) <expression>
- if (<Boolean expression>) <expression> else <expression>
匹配表达式（类似switch）
- Scala匹配表达式支持匹配如值、类型、正则表达式、数值范围和数据结构内容
```
<expression> match{
    case <pattern match> => <expression>
    [case ...]
}
```
- 可以使用模式替换式（pattern alternative），匹配多种内容
- case <pattern 1> | <pattern 2> .. => <one or more expressions>
- 增加通配模式，放止输入内容无法匹配的情况运行时异常
  - 值绑定模式case <identifier> => <one or more expressions>
    - 将输入绑定到一个特定的字面量上，如果不匹配就会进入这个绑定值的情况
  - 使用通配符 _：相当于匿名占位符，将在运行时替换为一个表达式的值
    - 与值绑定的不同在于不能再case表达式块中访问通配符的值
- 用模式哨位匹配
  - 增加一个if语句，为匹配表达式增加条件逻辑
  - case <pattern> if <Boolean expression> => <one or more expression>
- 用模式变量匹配类型
  - 匹配输入表达式的类型
  - case <identifier>: <type> => <one or more expressions>
循环
- Range（范围）数据结构
  - <starting integer> [to|until] <ending integer> [by increment]
- 基本for循环迭代处理
  - for (<indentifier> <- <iterator>) [yield] [<expression>]
  - yield:如果指定，则调用的所有表达式的返回值将作为一个集合返回，如果没有指定，则调用表达式，但是不能访问它的返回值
  - for (x <- 1 to 7){println(s"Day $x:")}
- 迭代器哨位（过滤器）
  - for (<indentifier> <- <iterator> if <Boolean expression>)...
  - threes = for(i <- 1 to 20 if i%3 == 0) yield i
- 嵌套迭代器
```
for{ x <- 1 to 2
     y <- 1 to 3 }
   { print(s"($x,$y) ")}
```
- 值绑定
  - for (<indentifier> <- <iterator>; <identifier> = <expression>)...
  - for(i <- 0 to 8; pow = 1 <<i) yield pow
- While和Do/While循环
  - while(<Boolean expression>) statement

函数

定义无输入的函数
- def <identifier> = <expression>
- def <identifier>() = <expression>
- 如果定义函数时没加小括号，则调用时也不可以加小括号，而加了小括号的无输入函数调用时可以不加小括号
定义函数时指定返回类型 def <identifier>: <type> = <expression>
定义函数 def <identifier>(<identifier>: <type>[,...]): <type> = <expression>
过程：没有返回值的函数
使用表达式块调用函数
- 当使用一个参数调用函数时，可以使用表达式块返回的结果发送参数
递归函数
- 递归函数可能会遇到“栈溢出”错误，Scala编译器可以使用尾递归优化一些递归函数
- 利用尾递归优化的函数，递归调用不会创建新的空间，而是使用当前函数的栈空间
- 只有最后一个语句是递归调用的函数才能由Scala编译器完成尾递归优化
- 可以利用函数注解来标志一个函数将完成尾递归优化@annotation.tailrec
嵌套函数
用命名参数调用函数
- 可以不按原先定义的顺序指定参数
有默认值的参数
Vararg参数
- 这是一个函数参数，可以匹配调用者的0个或多个实参
- vararg参数后面不能跟非vararg参数，因为无法加以区分
- vararg参数实现为一个集合，可以通过迭代器访问
- 要标志一个参数匹配一个或者多个输入实参，在函数定义中需要该参数类型后面增加一个*号
- 例如def sum(items: Int*): Int = {...}
参数组
- 可以把参数表分解为参数组，每个参数组用小括号分割
- 例如def max(x:Int)(y:Int) = if (x > y) x else y
类型参数
- 类型参数指示了值参数类型或返回值类型
- 函数参数或返回值的类型不再固定，而是可以由函数调用者设置
- def <function-name>[type-name](<parameter-name>:<type-name>): <type-name>...
- 例如def identity[A](a: A): A = a
方法和操作符
- 中缀点记法：<class instance>.<method>[(<parameters>)]
- Scala中使用的所有算术运算符都是方法
- Scala的操作符记法允许使用空格分隔对象、操作符方法和方法的参数（只有一个）
- 例如2 + 3和2.+(3)是一样的
- 操作符记法：<object> <method> <parameter>
  - 如果要调用多个参数，则必须将多个参数包含在()中

首类函数

“首类”表示函数不仅能得到声明和调用，还可以作为一个数据结构用在这个语言的任何地方
高阶函数：接受其他函数作为参数，或者使用函数作为返回值
声明式编程：要求使用高阶函数或其他机制声明要做的工作，而不手动实现
命令式编程：总要明确指定操作的逻辑流
函数类型和值
- 函数的类型是其输入类型与返回值类型的一个简单组合，用一个箭头从输入类型指向输出类型
- ([<type>, ...]) => <type>
```
def double(x: Int): Int = x*2
val myDouble: (Int) => Int = double
val myDoubleCopy = myDouble
val myDouble2 = double _
```
  - myDouble就是一个值，只不过这个值可以调用
  - 一个函数值可以赋值给一个新值
  - myDouble必须有显示的类型，以区分它是一个函数值，而不是一个函数调用（如果函数只有单个参数可以省略小括号）
  - val <identifier> = <function name> _：使用通配符为函数赋值
函数字面量
- 创建一个没有名字的函数并把这个函数赋值一个新的函数值
- val doubler = (x: Int) => x * 2
- 函数字面量是所赋数据的一个字面量表达式
- 其他名字：匿名函数、Lambda表达式、Lambdas、function0,function1,function2,...(Scala编译器对字面量的叫法。根据输入参数的个数而定，单参数就叫<function1>)
- 语法：([<identifier>: <type>, ...]) => <expression>
占位符语法
- 函数字面量的一种缩写形式，将命名参数替换为通配符（_）
- 使用条件
  - 函数的现实类型在字面量之外指定（明确好输入输出）
  - 输入参数最多只使用一次（因为只能按照位置匹配一次，多个占位符有着相同的符号，匹配之后就无法确定需要的参数）
- 示例
```
def combination(x: Int, y: Int, f: (Int,Int) => Int) = f(x,y)
combination(23, 12, _*_)
```
```
def tripleOp[A,B](a: A, b: A, c: A, f: (A, A, A) => B) => f(a, b, c)
tripleOp[Int, Int](23, 92, 14, _ * _ + _)
tripleOp[Int, Double](23, 92, 14, 1.0 * _ / _ / _)
```
部分应用函数和柯里化
- 功能：为函数保留一些重复使用的参数
- 方法一：部分应用（partially apply）函数，使用通配符替代其他参数（函数按位置匹配）
```
def factorOf(x: Int, y: Int) = y % x == 0
val mutipleOf3 = factorOf(3, _: Int)
val y = mutipleOf3(78)
```
- 方法二：函数柯里化（curring,讨好的意思），使用参数组
  - 有多个参数表的函数可以认为是多个函数的一个链。单个参数表则认为是一个单独的函数调用
```
def factorOf(x: Int)(y: Int) = y % x == 0
val isEven = factorOf(2) _
val z = isEven(32) // z = true
```
  - def factorOf(x: Int)(y: Int)的函数类型为 Int => Int => Boolean

传名参数

一种函数参数类型：可以取一个值，也可以取最终返回一个值的函数

语法：<identifier>: => <type>

scala> def doubles(x: => Int) = {
     |     println("Now doubling" + x)
     |     x * 2
     | }
doubles: (x: => Int)Int

scala> doubles(5)
Now doubling 5
res1: Int = 10

scala> def f(i: Int) = { println(s"Hello from f($i)"); i }
f: (i: Int)Int

scala> doubles( f(8) )
Hello from f(8)
Now doubling 8
Hello from f(8) //doubles调用两次x，所以f函数也调用两次
res2: Int = 16

偏函数
- 有些函数并不能支持满足输入类型的所有可能值。这种函数称为偏函数，因为它们只能部分应用于输入数据
用函数字面量块调用高阶函数
- 实际上就是输入的参数类型是函数，那个输入参数可以用表达式块或者函数字面量来代替
- 好处
  - 将单独的代码块包为在工具函数中
  - 管理数据库事务，即高阶函数打开会话，调用函数参数，然后commit或者rollback结束事务
  - 重新尝试处理可能的错误，将函数参数调用指定的次数，直到不再产生错误
  - 根据局部、全局或者外部值有条件地调用函数参数

常用集合

列表、集和映射
- List：不可变的单链表
  - 访问列表中的单个元素，可以作为一个函数调用这个列表，并提供一个索引号（从0开始）
  - List是一个不可变的递归数据结构（链表），列表中的每一项都有自己的表头和越来越短的表尾
  - 所有列表都有一个Nil实例作为终结点，可以通过比较当前元素与Nil来检查是否到达列表表尾（Nil实际上是List[Nothing]的一个单例实例）
- Set：不可变的无序集合
- Map：不可变的键值库，也称为散列映射、字典或关联数组
- List、Set、Map的根类型都是Iterable
  - foreach():取一个函数，对列表中的每一项，分别调用这个函数
  - map():取一个函数，将一个列表元素转换为另一个值或类型
  - reduce():取一个函数，将两个列表元素结合为一个元素
Cons操作符
- 可以通过cons（construct的简写）操作符来构建列表
- 使用Nil为基础，并使用右结合的cons操作符::绑定元素，就可以构建列表
```
val numbersOld = List(1,2,3)
val numbers = 1 :: 2 :: 3 :: Nil
```
- ::是List的一个方法，它取一个值，这会成为新列表的表头
```
val first = Nil.::(1) // 1 -> Nil
```
列表算术运算
- 因为List是一个不可变的集合，所有“修改”是指“返回一个新列表，其中包含所请求的修改”
- 谓词函数(predicate function)：得到一个输入值后会相应地返回true或false
- ::：为列表追加单个元素
- :::：为列表追加另一个列表
- ++：为列表追加另一个集合
- ==：判断集合类型和元素内容是否相同
- distinct：返回不包含重复的列表
- drop：去除列表前n个元素
- filter：输入一个谓词函数，过滤掉指定的元素
- flatten：将一个包含列表的列表转换为元素列表
- partition：输入一个谓词函数，将元素分组，由两个列表组成一个元组
- reverse：逆转列表
- slice：切片，输入切片的开头和结尾，输出不包括结尾
- sortBy：根据指定函数排序
- sorted：根据自然顺序排序
- splitAt：根据指定索引将列表切分成两个
- take：从列表抽取前n个元素
- zip：两个列表合并为一个元组列表
映射列表
- collect：使用偏函数转换各个元素，保留可应用的元素
- flatMap：给定一个函数转换各个元素，扁平化结果（消除列表中的列表，这种嵌套结构）
- map：使用给定函数转换各个元素
- Scala可以把Java数组转换为它自己的类型Array
归约列表
- 将列表收缩为单个值
- Scala的集合支持：
  - 数学归约：max、min、product、sum
  - 逻辑归约：contains、endsWith、exists、forall、startsWith
  - 通用的高阶操作，折叠，可以用来创建任何其他类型的列表归约算法
    - fold、foldLeft、foldRight、reduce、reduceLeft、reduceRight、scan、scanLeft、scanRight
转换集合
- mkString：根据指定分隔符将一个集合转换为String
- toBuffer：将一个不可变的集合转变为可变的集合
- toList：将一个集合转变为List
- toMap：将一个2元元组的集合转换为一个Map
- toSet：将一个集合转换为一个Set
- toString：将一个集合呈现为一个String，包括集合的类型
Java和Scala集合兼容性
- 默认情况下两者集合类型是不兼容的
- 添加JavaConverters：import collection.JavaConverters._
- 集合转换：asJava、asScala
使用集合的模式匹配
- 匹配表达式、模式哨卫、值绑定
- 模式匹配是Scala语言的一个核心特性

类

基础
- 在Scala中，类参数在类名后指定，就像函数定义中函数参数跟在函数名后面一样。类参数可以用来初始化字段（类中的值和变量），或者用于传入函数，但是一旦类已经创建，这些参数就不再可用
- 可以把某个字段声明为类参数，通过在类参数前增加val或者var，类参数就成为类中的一个字段
- Scala中，一个类可以使用extends关键字扩展最多一个其他类，另外可以用override关键字覆盖所继承方法的行为
- 类中的字段和方法用this关键字访问，父类中的字段和方法可以用super关键字访问
- Scala多态指类能够采用其他兼容类的形式。“兼容”指一个子类的实例可以用于替代其父类的实例，但是反过来不行

定义类

class <identifier>  [type-parameters]
                    [([val|var] <identifier>: <type>[, ...])] //输入参数可以有默认值
                    [extends <identifier>[type-parameters](<input parameters>)] //继承父类可以有输入参数
                    [{ fields, methods, and classes }]

实例就是一个内存分配，提供了类字段的存储空间。这个动作（即预留空间来分配一个类的内容）称为实例化
访问类的字段和方法：标准中缀点记法、中缀操作符记法

抽象类
- 将由其他类扩展的一个类，而自己不能实例化
- 由abstract关键字指定
- 定义其子类必须有的核心字段和方法，但一般不提供具体实现（可以有默认实现）
- 基于多态，如果一个值的类型为抽象类，它可以具体指向某个非抽象子类的实例，调用方法时实际上最后会在子类上调用
重载方法
apply方法
- 名为“apply”的方法有时是指它要作为一个默认方法或一个注入方法，可以直接调用而不需要方法名
- 实际是一种快捷方式，可以使用小括号触发功能而不需要方法名，就如python的__call__方法，以及pytorch的forward
懒值
- 定义一个值时可以在val关键字前面加上关键字lazy来创建一个懒值
- 类中使用的字段（值和变量）都是在类第一次实例化时创建的，而懒值是第一次调用时创建
- 要确保时间或者性能敏感操作在类的生命周期中只执行一次，懒值则是一种很好的方法
- 常用于存储基于文件的属性、打开的数据库链接，以及其他只有在确实必要时才初始化的不可变数据等信息。
包装
- 为Scala文件定义包：package <identifier>
- 源文件要存储在与包匹配的目录中
- 访问包装类：用点分隔的包路径或者导入包
- 与Java不同，代码中的任何位置都可以使用import，与python类似
- 支持使用_操作符导入一个包的全部内容
- 导入组：import <package>.{<class 1>[,<class 2>...]}
- 使用导入别名：import <package>.{<original name> => <alias>}
- 包装语法：包作为一个块，用大括号包围它的类 package <identifier> { <class definitions> }
私密性控制
- 默认地，Scala不会增加私密性控制
- protected：同一个类或者子类中的代码才能访问
- private：仅定义这个字段或方法的类可以访问
私密性访问修饰符
- 包级保护
  - 另外，可以根据另一个类的亲密性覆盖这些策略
- 实例级保护
最终类和密封类
- final类不能在子类中被覆盖，final关键字定义的值，变量或方法，可以确保所有子类都将使用这个实现
- sealed密封类
  - 密封类会限制一个类的子类必须位于福勒所在的同一个文件中

对象、Case类和Trait

对象object
- 一种类类型，只能有不超过1个实例，也就是单例（singleton）
- Java和其他语言的某些字段和方法为“静态”或“全局”，对象可以提供类似的功能，不过将它们与可实例化的类解耦合
- 对象不是用new关键字创建，只需要按名字直接访问，在首次访问时自动实例化（第一次访问前，不会实例化）
- 定义对象用object关键字，没有任何输入参数，对象不能扩展，但是别的类可以继承它
- 定义：object <identifier> [extends <identifier>] [{ fields, methods, and classes }]
- 最适合object的函数是纯函数和处理外部I/O的函数
  - 纯函数：会返回完全由其输入计算得到的结果，而没有任何副作用
  - I/O函数：处理外部数据的函数，如处理文件、数据库和外部服务
- apply方法和伴生对象
  - 工厂模式是一种很流行的方法，可以从伴生对象生成一个类的新实例。
  - 伴生对象是与类同名的一个对象，与类在同一个文件中定义
```
class Multiplier(val x: Int) { def product(y: Int) = x * y }
object Multiplier { def apply(x: Int) = new Multiplier(x) }
```
- 使用对象的命令行应用
  - 使用对象中的一个main方法作为应用的入口点
  - def main(args: Array[String]) { ... }
- Case类
```
case class <identifier> ([var] <identifier>: <type>[,...])
                         [extends <identifier>(<input-parameters>)]
                         [{ fields and methods }]
```
  - 不可实例化的类，包含多个自动生成的方法，包括一个自动生成的伴生对象
  - 适合数据传输对象，主要用于存储数据
  - val关键字可以用，但是case类默认将输入参数转换为值字段，所以没必要添加，如果需要一个变量字段，则使用var关键字
  - case类方法
    - apply：对象object中，一个工厂方法，用于实例化case类
    - copy：类中，返回实例的一个副本
    - equals：类中
    - hashCode：类中
    - toString：类中
    - unapply：对象中，将实例抽取到一个字段元组，从而可以使用case类实例完成模式匹配
- Trait
  - trait不能实例化，支持多重继承的类
  - trait不能有类参数，但可以有类型参数
  - 定义：trait <identifier> [extends <identifier>] [{ fields, methods, and classes }]
  - 用with关键字为类增加一个或多个trait，类没有扩展trait，而是被trait扩展，trait为现有的类增加新的功能或者配置，这个特性也称为依赖注入
    - Spring通过定制Java注解和初始化模块实现了类似的功能，但是Scala的trait不要求特定的注解或特殊的包来实现依赖注入
- 导入实例成员
  - 与导入类和对象的import使用方法一样，可以导入单个成员，或者通过通配符_导入所有成员
  - 不会覆盖私密性控制，只能导入可以正常访问的字段和方法

高级类型

暂略

Scala语言学习

Scala语言学习

Scala语言学习

基础

表达式和条件式

函数

首类函数

常用集合

更多集合

类

对象、Case类和Trait

高级类型

友情链接更多精彩内容