scala常見筆試題

Q1 var，val和def三個關鍵字之間的區別？

var是變數宣告關鍵字，類似于Java中的變數，變數值可以更改，但是變數型別不能更改，
val常量宣告關鍵字，
def 關鍵字用于創建方法（注意方法和函式的區別）
還有一個lazy val（惰性val）宣告，意思是當需要計算時才使用，避免重復計算

代碼示例：
var x = 3 //  x是Int型別
x = 4      // 
x = "error" // 型別變化，編譯器報錯'error: type mismatch'
val y = 3
y = 4        //常量值不可更改，報錯 'error: reassignment to val'
def fun(name: String) = "Hey! My name is: " + name
fun("Scala") // "Hey! My name is: Scala"
//注意scala中函式式編程一切都是運算式
lazy val x = {
  println("computing x")
  3
}
val y = {
  println("computing y")
  10
}
x+x  //
y+y  // x 沒有計算, 列印結果"computing y" 

Q2 trait（特質）和abstract class（抽象類）的區別？

（1）一個類只能集成一個抽象類，但是可以通過with關鍵字繼承多個特質；
（2）抽象類有帶引數的建構式，特質不行（如 trait t（i：Int）{} ，這種宣告是錯誤的）

Q3 object和class的區別？

object是類的單例物件，開發人員無需用new關鍵字實體化，如果物件的名稱和類名相同，這個物件就是伴生物件（深入了解請參考問題Q7）

代碼示例
//宣告一個類
class MyClass(number: Int, text: String) {
  def classMethod() = println(text)
}
//宣告一個物件
object MyObject{
  def objectMethod()=println("object")
}
new MyClass(3,"text").classMethod() //列印結果test，需要實體化類
Myclass.classMethod()  //無法直接呼叫類的方法
MyObject.objectMethod() //列印結果object，物件可以直接呼叫方法

Q4 case class （樣本類）是什么？

樣本類是一種不可變且可分解類的語法糖，這個語法糖的意思大概是在構建時，自動實作一些功能，樣本類具有以下特性：
（1）自動添加與類名一致的建構式（這個就是前面提到的伴生物件，通過apply方法實作），即構造物件時，不需要new；
（2）樣本類中的引數默認添加val關鍵字，即引數不能修改；
（3）默認實作了toString，equals，hashcode，copy等方法；
（4）樣本類可以通過==比較兩個物件，并且不在構造方法中定義的屬性不會用在比較上，

代碼示例
//宣告一個樣本類
case class MyCaseClass(number: Int, text: String, others: List[Int]){
 println(number)
}
//不需要new關鍵字，創建一個物件
val dto = MyCaseClass(3, "text", List.empty) //列印結果3
//利用樣本類默認實作的copy方法
dto.copy(number = 5) //列印結果5
val dto2 = MyCaseClass(3, "text", List.empty)
pringln(dto == dto2) // 回傳true，兩個不同的參考物件
class MyClass(number: Int, text: String, others: List[Int]) {}
val c1 = new MyClass(1, "txt", List.empty)
val c2 = new MyClass(1, "txt", List.empty)
println(c1 == c2 )// 回傳false,兩個不同的參考物件

Q5 Java和Scala 異步計算的區別？

really clean and simple answer on StackOverflow

詳細請轉https://blog.csdn.net/tao_jiayun/article/details/100549795

Q6 unapply 和apply方法的區別， 以及各自使用場景？

先講一個概念——提取器，它實作了構造器相反的效果，構造器從給定的引數創建一個物件，然而提取器卻從物件中提取出構造該物件的引數，scala標準庫預定義了一些提取器，如上面提到的樣本類中，會自動創建一個伴生物件（包含apply和unapply方法），
為了成為一個提取器，unapply方法需要被伴生物件，
apply方法是為了自動實作樣本類的物件，無需new關鍵字，

Q7 伴生物件是什么？

前面已經提到過，伴生物件就是與類名相同的物件，伴生物件可以訪問類中的私有量，類也可以訪問伴生物件中的私有方法，類似于Java類中的靜態方法，伴生物件必須和其對應的類定義在相同的源檔案，

代碼示例：
//定義一個類
class MyClass(number: Int, text: String) {
  private val classSecret = 42
  def x = MyClass.objectSecret + "?"  // MyClass.objectSecret->在類中可以訪問伴生物件的方法，在類的外部則無法訪問
}
//定義一個伴生物件
object MyClass { // 和類名稱相同
  private val objectSecret = "42"
  def y(arg: MyClass) = arg.classSecret -1 // arg.classSecret -> 在伴生物件中可以訪問類的常量
}
MyClass.objectSecret // 無法訪問
MyClass.classSecret // 無法訪問
new MyClass(-1, "random").objectSecret // 無法訪問
new MyClass(-1, "random").classSecret // 無法訪問

Q8 Scala型別系統中Nil, Null, None, Nothing四個型別的區別？

Null是一個trait（特質），是所以參考型別AnyRef的一個子型別，null是Null唯一的實體，
Nothing也是一個trait（特質），是所有型別Any（包括值型別和參考型別）的子型別，它不在有子型別，它也沒有實體，實際上為了一個方法拋出例外，通常會設定一個默認回傳型別，
Nil代表一個List空型別，等同List[Nothing]
None是Option monad的空標識（深入了解請參考問題Q11）

Q9 Unit型別是什么？

Unit代表沒有任何意義的值型別，類似于java中的void型別，他是anyval的子型別，僅有一個實體物件"( )"

Q10 call-by-value和call-by-name求值策略的區別？

（1）call-by-value是在呼叫函式之前計算；
（2） call-by-name是在需要時計算

 
示例代碼
//宣告第一個函式
def func(): Int = {
  println("computing stuff....")
  42 // return something
}
//宣告第二個函式，scala默認的求值就是call-by-value
def callByValue(x: Int) = {
  println("1st x: " + x)
  println("2nd x: " + x)
}
//宣告第三個函式，用=>表示call-by-name求值
def callByName(x: => Int) = {
  println("1st x: " + x)
  println("2nd x: " + x)
}
//開始呼叫
//call-by-value求值
callByValue(func())   
//輸出結果
//computing stuff....  
//1st x: 42  
//2nd x: 42
//call-by-name求值
callByName(func())   
//輸出結果
//computing stuff....  
//1st x: 42  
//computing stuff....
//2nd x: 42

Q11 Option型別的定義和使用場景？

在Java中，null是一個關鍵字，不是一個物件，當開發者希望回傳一個空物件時，卻回傳了一個關鍵字，為了解決這個問題，Scala建議開發者回傳值是空值時，使用Option型別，在Scala中null是Null的唯一物件，會引起例外，Option則可以避免，Option有兩個子型別，Some和None（空值）

代碼示例：
val person: Person = getPersonByIdOnDatabaseUnsafe(id = 4) // 如果沒有id=4的person時，回傳null物件
println(s"This person age is ${person.age}") //如果是null，拋出例外
val personOpt: Option[Person] = getPersonByIdOnDatabaseSafe(id = 4) // 如果沒有id=4的person時，回傳None型別
personOpt match {
  case Some(p) => println(s"This person age is ${p.age}")
  case None => println("There is no person with that id")
}

Q12 yield如何作業？

yield用于回圈迭代中生成新值，yield是comprehensions的一部分，是多個操作（foreach, map, flatMap, filter or withFilter）的composition語法糖，（深入了解請參考問題Q14）

代碼示例：
// <-表示回圈遍歷
scala> for (i <- 1 to 5) yield i * 2 
res0: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10)

Q13 解釋隱示引數的優先權

在Scala中implicit的功能很強大，當編譯器尋找implicits時，如果不注意隱式引數的優先權，可能會引起意外的錯誤，因此編譯器會按順序查找隱式關鍵字，順序如下：
（1）當前類宣告的implicits ；
（2）匯入包中的 implicits；
（3）外部域（宣告在外部域的implicts）；
（4）inheritance
（5）package object
（6）implicit scope like companion objects

Q14 comprehension（推導式）的語法糖是什么操作？

comprehension（推導式）是若干個操作組成的替代語法，如果不用yield關鍵字，comprehension（推導式）可以被forech操作替代，或者被map/flatMap，filter代替，

示例代碼：
// 三層回圈嵌套
for {
  x <- c1
  y <- c2
  z <- c3 if z > 0
} yield {...}
//上面的可轉換為
c1.flatMap(x => c2.flatMap(y => c3.withFilter(z => z > 0).map(z => {...})))

Q15 Streams：當使用Scala Steams時需要考慮什么？Scala的Streams內部使用什么技術？

Stream的應用場景及其實作原理 https://cuipengfei.me/blog/2014/10/23/scala-stream-application-scenario-and-how-its-implemented/

steam流 https://blog.csdn.net/weixin_40318210/article/details/83041265

Q16 什么是vaule class？

開發時經常遇到這個的問題，當你使用integer時，希望它代表一些東西，而不是全部東西，例如，一個integer代表年齡，另一個代表高度，由于上述原因，我們考慮包裹原始型別生成一個新的有意義的型別（如年齡型別和高度型別），
Value classes 允許開發者安全的增加一個新型別，避免運行時物件分配，有一些 必須進行分配的情況 and 限制,但是基本的思想是：在編譯時，通過使用原始型別替換值類實體，洗掉物件分配，

Q17 Option ，Try 和 Either 三者的區別？

這三種monads允許我們顯示函式沒有按預期執行的計算結果，
Option表示可選值，它的回傳型別是Some（代表回傳有效資料）或None（代表回傳空值），
Try類似于Java中的try/catch，如果計算成功，回傳Success的實體，如果拋出例外，回傳Failure，
Either可以提供一些計算失敗的資訊，Either有兩種可能回傳型別：預期/正確/成功的 和 錯誤的資訊，

 
代碼示例：代碼示例：
//回傳一個Either型別//回傳一個E
def personAge(id: Int): Either[String, Int] = {
  val personOpt: Option[Person] = DB.getPersonById(id) //回傳Option型別，如果為null回傳None，否則回傳Some
personOpt match {
    case None => Left(s"Could not get person with id: $id")  //Left 包含錯誤或無效值
    case Some(person) => Right(person.age)                    //Right包含正確或有效值
}

Q18 什么是函式柯里化？

柯里化技術是一個接受多個引數的函式轉化為接受其中幾個引數的函式，經常被用來處理高階函式，

代碼示例：
 
def add(a: Int)(b: Int) = a + b
val add2 = add(2)(_)  //_ 表示不只一個的意思
scala> add2(3)res0: Int = 5

Q19 什么是尾遞回？

正常遞回，每一次遞回步驟，需要保存資訊到堆疊里面，當遞回步驟很多時，導致堆疊溢位，
尾遞回就是為了解決上述問題，在尾遞回中所有的計算都是在遞回之前呼叫，
編譯器可以利用這個屬性避免堆疊錯誤，尾遞回的呼叫可以使資訊不插入堆疊，從而優化尾遞回，
使用 @tailrec 標簽可使編譯器強制使用尾遞回，

代碼示例：
def sum(n: Int): Int = { // 求和計算
  if(n == 0) {
    n
  } else {
    n + sum(n - 1)
  }
}
@tailrec  //告訴編譯器
def tailSum(n: Int, acc: Int = 0): Int = {
  if(n == 0) {
    acc
  } else {
    tailSum(n - 1, acc + n)
  }
}
sum(5)
5 + sum(4) // 暫停計算 => 需要添加資訊到堆疊
5 + (4 + sum(3))
5 + (4 + (3 + sum(2)))
5 + (4 + (3 + (2 + sum(1))))
5 + (4 + (3 + (2 + 1)))
15
 
tailSum(5) // tailSum(5, 0) 默認值是0
tailSum(4, 5) // 不需要暫停計算
tailSum(3, 9)
tailSum(2, 12)
tailSum(1, 14)
tailSum(0, 15)
15

Q20 什么是高階函式？

高階函式指能接受或者回傳其他函式的函式，scala中的filter map flatMap函式都能接受其他函式作為引數，