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

高級類型

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Scala語言學習

Scala語言學習

基礎

表達式和條件式

函數

首類函數

常用集合

更多集合

類

對象、Case類和Trait

高級類型

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频