【譯】Scala面試問題（Scala interview questions）

意譯一篇《scala面試問題》的博客，原文地址：http://pedrorijo.com/blog/scala-interview-questions/，
代碼示例我在本地做了驗證。

前言

這篇博客里面的問題，包含了Scala大量的語法，建議先學(xué)習Scala基礎(chǔ)知識，下面是一些學(xué)習資源。
基礎(chǔ)語法的學(xué)習推薦：
http://twitter.github.io/scala_school/zh_cn/ （Twitter的Scala課堂）
http://docs.scala-lang.org/tutorials/ （Scala官網(wǎng)的學(xué)習教程）
推薦視頻：http://www.imooc.com/learn/613 （慕課網(wǎng)scala視頻教程），這個視頻每集7分鐘左右，主要理解Scala函數(shù)式編程的思想。
推薦文章：https://www.zhihu.com/question/28292740 （函數(shù)式編程思維），和上面的視頻一起看，基本上是scala函數(shù)式編程的精髓。

下面開始翻譯原博客

Q1 var，val和def三個關(guān)鍵字之間的區(qū)別？

  • 答：var是變量聲明關(guān)鍵字，類似于Java中的變量，變量值可以更改，但是變量類型不能更改。
    val常量聲明關(guān)鍵字。
    def 關(guān)鍵字用于創(chuàng)建方法（注意方法和函數(shù)的區(qū)別）
    還有一個lazy val（惰性val）聲明，意思是當需要計算時才使用，避免重復(fù)計算

代碼示例：

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中函數(shù)式編程一切都是表達式
lazy val x = {
  println("computing x")
  3
}
val y = {
  println("computing y")
  10
}
x+x  //
y+y  // x 沒有計算, 打印結(jié)果"computing y"

Q2 trait（特質(zhì)）和abstract class（抽象類）的區(qū)別？

  • 答：（1）一個類只能集成一個抽象類，但是可以通過with關(guān)鍵字繼承多個特質(zhì)；
    （2）抽象類有帶參數(shù)的構(gòu)造函數(shù)，特質(zhì)不行（如 trait t（i：Int）{} ，這種聲明是錯誤的）

Q3 object和class的區(qū)別？

  • 答：object是類的單例對象，開發(fā)人員無需用new關(guān)鍵字實例化。如果對象的名稱和類名相同，這個對象就是伴生對象（深入了解請參考問題Q7）

代碼示例

//聲明一個類
class MyClass(number: Int, text: String) {
  def classMethod() = println(text)
}
//聲明一個對象
object MyObject{
  def objectMethod()=println("object")
}
new MyClass(3,"text").classMethod() //打印結(jié)果test，需要實例化類
Myclass.classMethod()  //無法直接調(diào)用類的方法
MyObject.objectMethod() //打印結(jié)果object，對象可以直接調(diào)用方法

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

  • 答：樣本類是一種不可變且可分解類的語法糖，這個語法糖的意思大概是在構(gòu)建時，自動實現(xiàn)一些功能。樣本類具有以下特性：
    （1）自動添加與類名一致的構(gòu)造函數(shù)（這個就是前面提到的伴生對象，通過apply方法實現(xiàn)），即構(gòu)造對象時，不需要new；
    （2）樣本類中的參數(shù)默認添加val關(guān)鍵字，即參數(shù)不能修改；
    （3）默認實現(xiàn)了toString，equals，hashcode，copy等方法；
    （4）樣本類可以通過==比較兩個對象，并且不在構(gòu)造方法中定義的屬性不會用在比較上。

代碼示例

//聲明一個樣本類
case class MyCaseClass(number: Int, text: String, others: List[Int]){
 println(number)
}
//不需要new關(guān)鍵字，創(chuàng)建一個對象
val dto = MyCaseClass(3, "text", List.empty) //打印結(jié)果3

//利用樣本類默認實現(xiàn)的copy方法
dto.copy(number = 5) //打印結(jié)果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 異步計算的區(qū)別？

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

  • 答：先講一個概念——提取器，它實現(xiàn)了構(gòu)造器相反的效果，構(gòu)造器從給定的參數(shù)創(chuàng)建一個對象，然而提取器卻從對象中提取出構(gòu)造該對象的參數(shù)，scala標準庫預(yù)定義了一些提取器，如上面提到的樣本類中，會自動創(chuàng)建一個伴生對象（包含apply和unapply方法）。
    為了成為一個提取器，unapply方法需要被伴生對象。
    apply方法是為了自動實現(xiàn)樣本類的對象，無需new關(guān)鍵字。

Q7 伴生對象是什么？

  • 答：前面已經(jīng)提到過，伴生對象就是與類名相同的對象，伴生對象可以訪問類中的私有量，類也可以訪問伴生對象中的私有方法，類似于Java類中的靜態(tài)方法。伴生對象必須和其對應(yīng)的類定義在相同的源文件。

代碼示例：

//定義一個類
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類型系統(tǒng)中Nil, Null, None, Nothing四個類型的區(qū)別？

  • 答：先看一幅Scala類型圖


    scala類型圖.png

    Null是一個trait（特質(zhì)），是所以引用類型AnyRef的一個子類型，null是Null唯一的實例。
    Nothing也是一個trait（特質(zhì)），是所有類型Any（包括值類型和引用類型）的子類型，它不在有子類型，它也沒有實例，實際上為了一個方法拋出異常，通常會設(shè)置一個默認返回類型。
    Nil代表一個List空類型，等同List[Nothing]
    None是Option monad的空標識（深入了解請參考問題Q11）

Q9 Unit類型是什么？

  • 答：Unit代表沒有任何意義的值類型，類似于java中的void類型，他是anyval的子類型，僅有一個實例對象"( )"

Q10 call-by-value和call-by-name求值策略的區(qū)別？

  • 答：（1）call-by-value是在調(diào)用函數(shù)之前計算；
    （2） call-by-name是在需要時計算

示例代碼

//聲明第一個函數(shù)
def func(): Int = {
  println("computing stuff....")
  42 // return something
}
//聲明第二個函數(shù)，scala默認的求值就是call-by-value
def callByValue(x: Int) = {
  println("1st x: " + x)
  println("2nd x: " + x)
}
//聲明第三個函數(shù)，用=>表示call-by-name求值
def callByName(x: => Int) = {
  println("1st x: " + x)
  println("2nd x: " + x)
}

//開始調(diào)用

//call-by-value求值
callByValue(func())   
//輸出結(jié)果
//computing stuff....  
//1st x: 42  
//2nd x: 42

//call-by-name求值
callByName(func())   
//輸出結(jié)果
//computing stuff....  
//1st x: 42  
//computing stuff....
//2nd x: 42

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

  • 答：在Java中，null是一個關(guān)鍵字，不是一個對象，當開發(fā)者希望返回一個空對象時，卻返回了一個關(guān)鍵字，為了解決這個問題，Scala建議開發(fā)者返回值是空值時，使用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用于循環(huán)迭代中生成新值，yield是comprehensions的一部分，是多個操作（foreach, map, flatMap, filter or withFilter）的composition語法糖。（深入了解請參考問題Q14）

代碼示例：

// <-表示循環(huán)遍歷
scala> for (i <- 1 to 5) yield i * 2 
res0: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10)

Q13 解釋隱示參數(shù)的優(yōu)先權(quán)

  • 答：在Scala中implicit的功能很強大。當編譯器尋找implicits時，如果不注意隱式參數(shù)的優(yōu)先權(quán)，可能會引起意外的錯誤。因此編譯器會按順序查找隱式關(guān)鍵字。順序如下：
    （1）當前類聲明的implicits ；
    （2）導(dǎo)入包中的 implicits；
    （3）外部域（聲明在外部域的implicts）；
    （4）inheritance
    （5）package object
    （6）implicit scope like companion objects
    一個參考文章：set of examples can be found here.
    個人推薦一篇文檔：Where do Implicits Come From?

Q14 comprehension（推導(dǎo)式）的語法糖是什么操作？

  • 答：comprehension（推導(dǎo)式）是若干個操作組成的替代語法。如果不用yield關(guān)鍵字，comprehension（推導(dǎo)式）可以被forech操作替代，或者被map/flatMap，filter代替。

示例代碼：

//三層循環(huán)嵌套
for {
  x <- c1
  y <- c2
  z <- c3 if z > 0
} yield {...}

//上面的可轉(zhuǎn)換為
c1.flatMap(x => c2.flatMap(y => c3.withFilter(z => z > 0).map(z => {...})))

更多例子 More examples by Lo?c Descotte.

Q15 Streams：當使用Scala Steams時需要考慮什么？Scala的Streams內(nèi)部使用什么技術(shù)？

  • 答：還沒有理解，暫時不翻譯，后續(xù)補上。

Q16 什么是vaule class？

  • 答：開發(fā)時經(jīng)常遇到這個的問題，當你使用integer時，希望它代表一些東西，而不是全部東西，例如，一個integer代表年齡，另一個代表高度。由于上述原因，我們考慮包裹原始類型生成一個新的有意義的類型（如年齡類型和高度類型）。
    Value classes 允許開發(fā)者安全的增加一個新類型，避免運行時對象分配。有一些 必須進行分配的情況 and 限制,但是基本的思想是：在編譯時，通過使用原始類型替換值類實例，刪除對象分配。更多細節(jié)More details can be found on its SIP.

Q17 Option ，Try 和 Either 三者的區(qū)別？

  • 答：這三種monads允許我們顯示函數(shù)沒有按預(yù)期執(zhí)行的計算結(jié)果。
    Option表示可選值，它的返回類型是Some（代表返回有效數(shù)據(jù)）或None（代表返回空值）。
    Try類似于Java中的try/catch，如果計算成功，返回Success的實例，如果拋出異常，返回Failure。
    Either可以提供一些計算失敗的信息，Either有兩種可能返回類型：預(yù)期/正確/成功的 和 錯誤的信息。

代碼示例：

//返回一個Either類型
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 什么是函數(shù)柯里化？

  • 答：柯里化技術(shù)是一個接受多個參數(shù)的函數(shù)轉(zhuǎn)化為接受其中幾個參數(shù)的函數(shù)。經(jīng)常被用來處理高階函數(shù)。

代碼示例：

def add(a: Int)(b: Int) = a + b

val add2 = add(2)(_)  //_ 表示不只一個的意思

scala> add2(3)
res0: Int = 5

Q19 什么是尾遞歸？

正常遞歸，每一次遞歸步驟，需要保存信息到堆棧里面，當遞歸步驟很多時，導(dǎo)致堆棧溢出。
尾遞歸就是為了解決上述問題，在尾遞歸中所有的計算都是在遞歸之前調(diào)用，
編譯器可以利用這個屬性避免堆棧錯誤，尾遞歸的調(diào)用可以使信息不插入堆棧，從而優(yōu)化尾遞歸。
使用 @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 什么是高階函數(shù)？

  • 答：高階函數(shù)指能接受或者返回其他函數(shù)的函數(shù)，scala中的filter map flatMap函數(shù)都能接受其他函數(shù)作為參數(shù)。
翻譯結(jié)束

個人總結(jié)

1 monads概念的需要進一步理解
2.Scala Steams使用的內(nèi)部技術(shù)
3 Scala中隱形參數(shù)的使用
4 高階函數(shù)的靈活運用

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容