scala练习100道解析

1、[primary]关于和Scala进行交互的基本方式REPL说法错误的是? C
A、R 读取（read）
B、E 求值（evaluate）
C、P 解析（Parse）
D、L 循环（Loop）

Read -> Eval -> Print -> Read

2、不属于Scala7种数值类型的是? D

A、Char
B、Int
C、Float
D、LongLong

3、[primary]如果需要使用scala库中的sqrt函数,如sqrt(2)，下列引用包的方式错误的是? B

A、import scala.math._
B、import sqrt
C、import math._
D、import math.sqrt

4、[primary]Scala关于变量定义、赋值，错误的是？B

A、val a = 3
B、val a:String = 3
C、var b:Int = 3 ; b = 6
D、var b = “Hello World!” ; b = “123”

val a:String = 3 类型不匹配

5、[primary]在Scala中如何获取字符串“Hello”的首字符和尾字符？B

A、“Hello”(0)，“Hello”(5)
B、“Hello”.take(1)，“Hello”.reverse(0)
C、“Hello”(1)，“Hello”(5)
D、“Hello”.take(0)， “Hello”.takeRight(1)

6、[primary]下面输出与其他不一致的是？D

A、println(“Hello World”)
B、print(“Hello World\n”)
C、printf(“Hello %s”, “World\n”)
D、val w = “World” ; println(“Hello $w”)

scala> val w = "World" ; println("Hello $w")
Hello $w

7、[primary]关于函数def sum(args:Int) = {var r = 0 ; for(arg <- args) r += arg ; r}} 输出结果不一致的是？D*

A、sum(1,2,3)
B、sum(6)
C、sum(2,4)
D、sum(1,1,1,2)

  print( sum(1,1,1,2))//5

8、[primary]下列表达式不是过程的是？C

A、def foo(num:Int) = {println(num * 2)}
B、def foo() {println(“Hello World”)}
C、def foo(num:Int) = {num * 2}
D、def foo():Unit = {println(“Hello World”)}

scala> def foo() {println("Hello World")}
foo: ()Unit

scala> def foo(num:Int) = {num * 2}
foo: (num: Int)Int

9、下列数组定义与其他不一致的是？D

A、val a = Array[Int](0, 0)
B、val a = Array(0, 0)
C、val a = new ArrayInt
D、val a = Array[Int](1, 1)

scala> val a = Array[Int](1, 1)
a: Array[Int] = Array(1, 1)

scala> val a = Array[Int](0, 0)
a: Array[Int] = Array(0, 0)

scala> val a = new Array[Int](2)
a: Array[Int] = Array(0, 0)

scala> val a = Array(0, 0)
a: Array[Int] = Array(0, 0)

10、[primary]下列关于数组缓冲val b = ArrayBufferInt操作结果的注释说明错误的是？C

A、b += 1 // b 等于 ArrayBuffer(1)
B、b += (1,2,3) // b 等于 ArrayBuffer(1,2,3)
C、b += Array(1,2) // b 等于 ArrayBuffer(1,2)
D、b += (1,2,3,4,5);b.trimEnd(3) // b 等于 ArrayBuffer(1,2)

++ 可以追加数组

scala> b += Array(1,2)
<console>:14: error: type mismatch;
 found   : Array[Int]
 required: Int
       b += Array(1,2)
                 ^

scala> b+=1
res51: b.type = ArrayBuffer(1)

11、[primary]关于数组的常用算法，下列说法错误的是？B

A、Array(1,7,2,9).sum // 等于 19
B、Array(1,7,2,9).sorted // 等于 Array(9,7,2,1)
C、Array(“one”,“two”,“three”).max // 等于 “two”
D、Array(“one”,“two”,“three”).mkString("-") // 等于 “one-two-three”

scala> Array(1,7,2,9).sorted
res56: Array[Int] = Array(1, 2, 7, 9)

12、[primary]关于元组 Tuple 说法错误的是？D

A、元组的可以包含不同类型的元素
B、元组是不可变的
C、访问元组第一个元素的方式为 pair._1
D、元组最多只有2个元素

13、**[primary]**对于函数

def getGoodsPrice(goods:String) = {
val prices = Map(“book” -> 5, “pen” -> 2, “sticker” -> 1)
prices.getOrElse(goods, 0)
}

结果说法错误的是？D

A、getGoodsPrice(“book”) // 等于 5
B、getGoodsPrice(“pen”) // 等于 2
C、getGoodsPrice(“sticker”) // 等于 1
D、getGoodsPrice(“sock”) // 等于 “sock”

14、[primary]对于元组val t = (1, 3.14, "Fred")说法错误的是？A

A、t_1 等于 1
B、t 的类型为 Tuple3[Int, Double, java.lang.String]
C、val (first, second, _) = t // second 等于 3.14
D、t._0无法访问， 会抛出异常

scala> t._1
res60: Int = 1

15、[primary]对于拉链操作val t1 = Array(1, 3); val t2 = Array(2,4) ; t1.zip(t2)返回结果正确的是？C

A、（1,2,3,4)
B、（(1,3),(2,4))
C、（(1,2),(3,4))
D、（(1,4),(3,4))

16、[intermediate]*Scala允许你用数字去乘字符串—去REPL中试一下"crazy"3。这个操作结果返回什么？C

A、“crazy”*3
B、ccrraazzyy
C、crazycrazycrazy
D、crazy

17、[intermediate]下面选项中a的取值不一致的是？B

A、val a = 3
B、val a:Double = 1 + 2
C、var a = 1; a += 2
D、val b = 1.+(2); val a = b.toInt

18、[intermediate]指出在Scala中何种情况下赋值语句x=y=1是合法的？A

A、var x={}
B、var x=1
C、var x=“test”
D、var x=(1,1)

19、**[intermediate]**编写一个过程countdown(n:Int)，打印从n到0的数字？C

A、

def countdown(n:Int){
0 to n foreach print
}

B、

def countdown(n:Int){
(0 until n).reverse foreach print
}

C、

def countdown(n:Int){
(0 to n).reverse foreach print
}

D、

def countdown(n:Int){
(0 to n-1).reverse foreach print
}

20、[intermediate]表达式for(i <- 1 to 3; for(j <- 1 to 3; if i != j ) print((10 * i + j)) + " "输出结果正确的是？C

A、11 12 13 21 22 23 31 32 33
B、11 13 21 23 31 33
C、12 13 21 23 31 32
D、11 12 21 22 31 32

21、[intermediate]**关于函数

def fac(n:Int) = { var r = 1 ; for(i <- 1 to n) r = r * i ; r} fac(5)

输出结果正确的是？B**

A、15
B、120
C、200
D、300

22、**[intermediate]**关于函数

def fac(n: Int, x: String = "x", y: Int = 0) = {
    println(x * (n + y))
  }

输出结果不一致的是？C

A、fac(2)
B、fac(1, y=1)
C、fac(1, “x”)
D、fac(1, “x”, 1)

scala> fac(2)
xx

scala> fac(1,y=1)
xx

scala> fac(1,"x")
x

23、**[intermediate]**关于数组val a = Array(1,2,3)下列说法错误的是？A

A、val b = 2 * a // b 等于 Array(2,4,6)
B、val b = a.map(_*2) // b 等于 Array(2,4,6)
C、val b = for(elem <- a) yield 2 * elem // b 等于 Array(2,4,6)
D、val b = for(elem <- a if elem % 2 == 0) yield 2 * elem // b 等于 Array(4)

24、**[intermediate]**关于数组Array.ofDim[Int](2,3)的初始化结果说明正确的是？B

A、Array(0，0，0，0，0，0）
B、Array(Array(0，0，0)，Array(0，0，0)）
C、Array(Array(0，0)，Array(0，0)，Array(0，0)）
D、(Array(0，0)，Array(0，0)，Array(0，0))

25、**[intermediate]**对于Map("book" -> 5, "pen" -> 2).map(m => m._1 -> m._2 * 2)结果说法正确的是？C

A、Map(“bookbook” -> 5, “penpen” -> 2)
B、Map(“bookbook” -> 10, “penpen” -> 4)
C、Map(“book” -> 10, “pen” -> 4)
D、Map(“book” -> 5, “pen” -> 2 ,“book” -> 5, “pen” -> 2)

26、**[intermediate]**对于val prices = Map("book" -> 5, "pen" -> 2, "sticker" -> 1)结果说法错误的是？D

A、prices(“sticker”) // 等于 1
B、(prices + (“shoes” -> 30))(“shoes”)// 等于 30
C、(prices - “pen”)(“book”) // 等于 5
D、prices(“sock”) // 等于 0

27、**[intermediate]**对于表达式"New York".partition(_.isUpper)返回结果正确的是？B

A、(“New”, “York”)
B、(“NY”, “er ork”)
C、(“er ork”, “NY”)
D、(“New York”, “NY”)

scala> "New York".partition(_.isUpper)
res65: (String, String) = (NY,ew ork)

scala> "New York".partition(_.isLower)
res66: (String, String) = (ework,N Y)

28、**[intermediate]**对于表达式

val tokens = "one two three four two two three four".split(" ")
val map = new HashMap[String,Int]
for(key <- tokens){
map(key) = map.getOrElse(key,0) + 1
}

说法正确的是？D

A、map(“one”) 等于 2
B、map(“two”) 等于 2
C、map(“three”) 等于 3
D、map(“four”) 等于 2

Map(one -> 1, three -> 2, four -> 2, two -> 3)

向map里添加元素可以直接赋值,也可以y是update. key来源于tokens数组,value是这个key的个数

 val tokens = "one two three four two two three four".split(" ")
    val map = new mutable.HashMap[String,Int]
    for(key <- tokens){
      map.update(key,map.getOrElse(key,0)+1)
    }

29、**[intermediate]**编写一个函数，返回Int数组中最大最小的数字？B

A、

def maxmin(nums:Array[Int]){
val max = nums.max
val min = nums.min
(max, min)
}

B、

def maxmin(nums:Array[Int]) = {
nums.max -> nums.min
}

C、

def maxmin(nums:Array[Int]) = {
val max = nums.max
val min = nums.min
max,min
}

D、

def maxmin(nums:Array[Int]) = {
val max = nums.sorted.head
val min = nums.sorted.last
(max,min)
}

30、**[intermediate]**对于拉链操作

val key = Array(1, 2)
val value = Array(“one”,”two”)
val m = key.zip(value).toMap

返回结果正确的是？A

A、m(1) 等于 “one”
B、m(2) 等于 “one”
C、m(“one”) 等于 “1”
D、m(“two”) 等于 1

scala> val value = Array("one","two")
value: Array[String] = Array(one, two)

scala> val key = Array(1, 2)
key: Array[Int] = Array(1, 2)

scala> key.zip(value)
res3: Array[(Int, String)] = Array((1,one), (2,two))

scala> res3.toMap
res4: scala.collection.immutable.Map[Int,String] = Map(1 -> one, 2 -> two)

scala> res4(1)
res5: String = one

31、[primary]scala中，下面的哪个类定义是不正确的？C

A.class Counter{def counter = “counter”}
B.class Counter{val counter = “counter”}
C.class Counter{var counter:String}
D.class Counter{def counter () {}}

32、[primary]scala的类在实现属性时，下面说法中错误的是？B

A. var foo： Scala自动合成一个getter 和一个setter
B. val foo： Scala自动合成一个getter 和一个setter
C. 可以单独定义foo方法
D. 可以单独定义foo_=方法

33、[primary] 定义类Countter并实例化如下：

class Countter(name:String){
val a = 1
var b = "counter"
}
val counter = new Countter("computer")

下列操作正确的是？C

A. counter.name = “cpu”
B. counter.a = 2
C. counter.b = “conter2”
D. counter.a = counter.b

scala> counter.name
<console>:15: error: value name is not a member of Countter
       counter.name

34、**[primary]**类和单例对象间的差别是？B

A. 单例对象不可以定义方法，而类可以
B. 单例对象不可以带参数，而类可以
C. 单例对象不可以定义私有属性，而类可以
D. 单例对象不可以继承，而类可以

35、**[primary]**关于辅助构造器，以下说法正确的是？C

A. 辅助构造器的必须调用主构造器
B. 辅助构造器的可以直接调用超类的主构造器
C. 辅助构造器的参数可以是任意多个
D. 辅助构造器的名称和类名相同

36、**[primary]**关于主构造器，以下说法错误的是？A

A. 主构造器在每个类都可以定义多个
B. 主构造器的参数可以直接放在类名后。
C. 主构造器的会执行类定义中的所有语句。
D. 主构造器中可以使用默认参数。

37、**[primary]**定义类 Class Person（private val name: String）{},以下说法正确是？B

A. name是对象私有字段
B. name是类私有字段，有私有的getter方法
C. name是类公有字段，有公有的getter和setter方法
D. name是类私有字段，可以在类内部被改变

38、scala 中，以下说法错误是？C

A. scala 中， 可以在类中定义类。
B. scala 中， 可以在函数中定义函数。
C. scala 中， 不可以在类中定义object。
D. scala 中， 可以在函数中定义类。

39、scala 中，类成员的缺省访问级别是？A

A. public
B. private
C. protected
D. 以上都不对

40、以下单例对象，定义错误的是？B

A. object A{var str = “”}。
B. object A(str:String){}
C. object A{def str = “”}
D. object A{val str = “”}

41、scala中，关于包的说法不正确的是？A

A. 包的名称不能重复。
B. 同一个包可以定义在多个文件中。
C. 包路径不是绝对路径。
D. 包对象可以持有函数和变量。

42、scala中，关于包的引用错误的是？D

A. 包和其成员可以用import
B. 可以引用某个文件夹下的特定文件
C. 可以引用某个文件夹下的所有文件
D. 包引用只能在编译单元的开始处

43、下面关于override修饰符的描述错误的是？D

A. Scala里所有重载了父类具体成员的成员都需要这样的修饰符
B. Scala里如果子类成员实现的是同名的抽象成员则这个修饰符是可选的
C. Scala里如果子类中并未重载或实现什么基类里的成员则禁用这个修饰符
D. Scala里如果子类是抽象类则子类的同名成员不可以使用这个修饰符

44、Scala里，final修饰符的描述正确的是？B

A. 类的声明上添加final修饰符确保成员不被子类重载
B. 类的声明上添加final修饰符把整个类声明为final，这个类不能被继承
C. 类的声明上添加final修饰符确保成员只能被子类重载一次
D. 以上说法都是错误的

45、scala语言中，关于List的定义。不正确的是？C

A. val list = List(1,2,3)。
B. val list = List[Int](1,2,3)。
C. val list = List[String](‘a’,’b’,’c’)。
D. val list = List[String]()。

46、定义一个类，定义正确的是？D

A.

class House（name）{
def getname = “beijing”
}

B.

class house {
name = “nanjing”
}

C.

class House {
public var counter:String = “shanghai”
}

D.

class house (var name:String){
private def getName = name
}

47、Scala类中的公有字段自带getter和setter，类class Persen{var age=0} ，age字段默认定义的方法是？D

A. getter ,setter
B. getAge, setAge
C. age, age_
D. age, age_=

48、关于辅助构造器，以下说法不正确的是？D

A. 辅助构造器的名称为this。
B. 辅助构造器的定义要调用已定义的辅助构造器或主构造器。
C. 辅助构造器可以有任意多个
D. 辅助构造器必须要带参数

49、Scala中的类，以下说法正确的是？B

A. Scala中，类内部的不是从构造器定义的代码，都会在主构造器中执行
B. Scala中，类内部的不是字段的部分或者方法定义的代码，都会在主构造器中执行
C. Scala中，类内部的所有的代码，都会在主构造器中执行
D. 以上说法都是错误的。

50、scala 中，类和它的伴生对象说法错误的是？B

A. 类和它的伴生对象定义在同一个文件中。
B. 类和它的伴生对象可以有不同的名称。
C. 类和它的伴生对象可以互相访问私有特性。
D. 类和它的伴生对象可以实现既有实例方法又有静态方法。

51、关于对象的apply方法，正确的是？A

A. apply方法返回的是伴生类的对象。
B. apply方法不可以带参数。
C. apply方法返回的是Unit。
D. apply方法定义在类里面。

52、scala中，关于引入语句的说法不正确的是？D

A. 引入语句可以引入包、类和对象。
B. 引入语句可以出现在任意位置。
C. 引入语句可以重命名。
D. 引入语句不可以隐藏特定成员。

53、对于下述代码说法正确的是？A

class Cat extends Animal{}

A. Cat是Animal的子类。
B. Animal是Cat的子类
C. Cat是Animal的超类
D. Animal一定是抽象类

54、scala中的类，下面说法正确的是？A

A. scala 中，使用extends进行类的扩展。
B. scala 中, 声明为final的类可以被继承。
C. scala中，超类必须是抽象类。
D. scala中，抽象类可以被实例化。

55、scala中，下列描述错误的是？B

A. Scala里，字段和方法属于相同的命名空间。
B. Scala一共有四个命名空间。
C. Scala里，字段可以重载无参数方法。
D. Scala类和特质属于相同的命名空间。

56、下面定义的代码和哪个选项是等效的？D

class ArrayElement(x123: Array[String]) extends Element{
val contents: Array[String] = x123
}

A.

class ArrayElement(var x123: Array[String])extends Element{
val contents: Array[String] = x123
}
B.

class ArrayElement( val x123: Array[String] )extends Element{
val contents: Array[String] = x123
}
C.

class ArrayElement(var contents: Array[String])extends Element
D.

class ArrayElement( val contents: Array[String] )extends Element
57、类定义如下，描述不正确的是？C

abstract class Element
{
def contents: Array[String]
}

A. Element是一个抽象类。
B. Element不能实例化。
C. Contents成员定义错误，没有初始化。
D. contents方法是类Element的抽象成员。

58、scala语言中，下面描述正确的是？D

A. scala中，Float是Double的子类。
B. scala中，Int是Long的子类。
C. scala中，Double是AnyRef的子类
D. scala中，Long是AnyVal的子类

final abstract class Long private extends AnyVal
abstract final class Double extends AnyVal

59、Scala中，下面的代码执行正确的是?C

A. val list = 1 :: 2 :: 3。
B. val list = 1.::(2).:: (3).::(Nil)
C. val list = 1 :: “s” :: “b” :: Nil。
D. var list = 1 ::: 2 ::: 3 ::: Nil

scala> val list = 1 :: "s" :: "b" :: Nil
list: List[Any] = List(1, s, b)

60、类ArrayElement定义如下,它的子类定义正确的是？B

class ArrayElement(val str:String){
def height =1
}

A.

class LineElement(str: String) extends ArrayElement{
def width = str.length
}

B.

class LineElement(s: String) extends ArrayElement(s) {
def width = str.length
}

C.

class LineElement(str: String) extends ArrayElement(str){
def height =1
}

D.

class LineElement(s String) extends ArrayElement{
def str = s
}

scala> class LineElement(str: String) extends ArrayElement(str){
     | def height =1
     | }
<console>:14: error: overriding method height in class ArrayElement of type => Int;
 method height needs `override' modifier
       def height =1
           ^

61、对于由scala.io.Source.fromFile创建的Source对象的使用以下描述正确的是？A

A. 在使用完此Source对象后，需要调用close方法来释放相关资源。
B. 可以使用此Source对象向其指定的文件中写入内容。
C. 可以修改此Source对象所指定的文件名称。
D. 以上说法均不正确。

62、在正则表达式中，如下哪个符号用于匹配单个字符？B

A. .
B. ?
C. *
D. +

63、在正则表达式中，如下哪个符号用于匹配一次或多次？D

A. .
B. ?
C. *
D. +

64、可以正确匹配" 12340 "的正则表达式是？C

A. "\s+[0-9]+\s+".r
B. ""\s+[0-4]+\s+".r
C. """\s+\d+\s+""".r
D. 以上均不正确。

65、如下选项中，不能做为Scala标识符的是？C

A. `type`
B. |>
C. 2K
D. hello

66、下述关于中置表达式(a 操作符 b)的描述错误的是？B

A. 其中的“操作符”代表一个带有两个参数的方法(一个隐式的参数和一个显式的参数)。
B. 中置表达式，一定可以提高代码的可阅读性。
C. Scala在当方法只有一个参数时，可以省略点号、以及括号，从而形式上变成中置表达式。
D. 通常可以将此中置表达式修改为"a.操作符(b)"，若此操作符具有右结合性则应修改为"b.操作符(a)"。

67、有关操作符结合性的描述不正确的是？D

A. 操作符的结合性决定了它们是从左到右求值还是从右到左求值。
B. |操作符是左结合的。
C. 以冒号结尾的操作符是右结合的。
D. 赋值操作符是左结合的。

68、以下代码的执行结果的描述正确的是？C

object Name {
def unapplySeq(input: String): Option[Seq[String]] = {
if(input.trim == "") None else Some(input.trim.split("\\s+"))
}
}
 
val Name(xing, ming) = " Yuan Jianzheng "

A. 编译过程报错。
B. 运行过程中报错。
C. 执行后，xing的结果是"Yuan"，ming的结果是"Jianzheng"。
D. 以上描述全部错误。

69、以下关于闭包描述错误的是？D

A. 闭包是一个函数，其返回值依赖于声明在函数包部的一个或多个变量。
B. 通常来讲，可以将闭包看作是可以访问一个函数里面局部变量的另一个函数。
C. 对于def mulBy(factor: Double) = (x: Double) => factor * x; val triple = mulBy(3);,函数triple是一个闭包。
D. 对于def mulBy(factor: Double) = (x: Double) => 3 * x; val triple = mulBy(3);,函数triple是一个闭包。

70、有关柯里化描述错误的是？D

A. 柯里化是指将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数作为参数的函数。
B. 有时，使用柯里化将某个函数参数单拎出来，可以提供更多用于类型推断的信息。
C. 将函数def add(x: Int, y: Int) = x + y，变形为def add(x: Int)(y: Int) = x + y的过程是一个柯里化过程。
D. 柯里化是多参数列表函数的特例。

71、高阶函数是指？C

A. 在程序中应该首先被定义的函数。
B. 将函数作为参数，并返回结果为函数的函数。
C. 函数参数为函数或返回结果为函数的函数。
D. 执行时间长的函数。

72、以下选项中，哪一个可以在Scala中定义一个按名调用(call-by-name)的函数？B

A. def functionOne(x: Int)
B. def functionOne(x: => Int)
C. def functionOne(x: -> Int)
D. def functionOne(x: Name)

73、如下代码执行结果是？A

def someCurring(y: Int):(Int) => Int = {
def s(y:Int) = 2*y
s
}
val result = somCurring(4)(3)

A. 6
B. 4
C. 8
D. 9

//题目出的有点迷惑性,传入的第一个参数其实函数体根本就没用过
object _01Test {
  def main(args: Array[String]): Unit = {
    val result = someCurring(4)(3)
    print(result)//6
  }

  def someCurring(y: Int): (Int) => Int = {
    def s(t: Int) = 2 * t

    s
  }
}

74、集合可以分为三大类，以下描述中不是这三大类的是？A

A. 列表(List)
B. 序列(Seq)
C. 集(Set)
D. 映射(Map)

75、以下对集合的描述有误的是？D

A. Set是一组没有先后次序的值。
B. Map是一组(键，值)对偶。
C. 每个Scala集合特质或类都有一个带有apply方法的伴生对象，可以用此方法来构建该集合中的实例。
D. 为了顾及安全性问题，Scala仅支持不可变集合而不支持可变集合。

76、 如下的操作中，哪一个不能将val names = List(“Petter”, “Paul”, “Mary”)中的相应地字符串全部变成大写？D

A. names.map(_.toUpperCase)
B. for (name <- names) yield name.toUpperCase
C. for (name <- names) yield
　for(c <- name) yield c.toUpper
D. for(name <- names;
c <- name) yield c.toUpper

77、以下关于case class描述有误的是？A

A. 默认情况下可对其属性进行修改。
B. 在模式匹配时会进行解构操作。
C. 两个case class进行比较时进行全等比较，而非按是否引用同一个对象进行比较。
D. 相比于class而言更简洁的实例化过程(不需要使用new操作符)及其它操作语法。

78、下面有关sealed类的描述有误的是？D

A. 若样例类的通用超类声明为sealed，则在使用样例类来做模式匹配时，编译器可以确保你已经列出了所有可能的选择。
B. 对于用sealed声明的类，其子类必须与其处于同一个文件中。
C. 声明为sealed的类可以有效防止继承滥用。
D. 声明为sealed的类由于是密封的，故不能对此类中实现的方法在子类中进行修改。

79、下面有Option类型描述有误的是？C

A. Option类型可以用来表示那种可能存在、也可能不存在的值。
B. Option类型的两种状态分别是Some和None。
C. Option类型的两种状态分别是Success和Failure。
D. 可以使用isEmpty方法来判断是否存在值。

80、对于以下代码描述有误的是？B

val data = Map(1 -> "One", 2 -> "Two")
val res = for((k, v) <- data; if(k > 1)) yield v

A. 运行后res的结果为List(“Two”)。
B. 运行后res的结果为List(“One”, “Two”)。
C. 对映射data中的每一个(键，值)对，k被绑定对键，而v则被绑定到值。
D. 其中的if(k > 1)是一个守卫表达式。

scala> val res = for((k, v) <- data; if(k > 1)) yield (k,v)
res: scala.collection.immutable.Map[Int,String] = Map(2 -> Two)

scala> val res = for((k, v) <- data; if(k > 1)) yield k
res: scala.collection.immutable.Iterable[Int] = List(2)

scala> val res = for((k, v) <- data; if(k > 1)) yield v
res: scala.collection.immutable.Iterable[String] = List(Two)

81、对于scala.io.Source对象的fromFile来说，以下哪一种描述是错误的？C

A. 可以使用指定文件名(String)来创建一个Source
B. 可以使用一个文件的URI(java.net.URI)来创建一个Source
C. 可以使用一个文件的URL(java.net.URL)来创建一个Source
D. 可以使用一个File对象(java.io.File)来创建一个Source

82、对于在scala中文件相关操作描述正确的是？D

A. 可以直接使用scala的库来读取二进制文件。
B. 可以直接使用scala的库来写入文件文件。
C. 在读取文件时，如果不指定文件编码格式则scala会推断出正确的格式进行读取。
D. 以上描述均不正确。

83、对于scala.sys.process提供用于与shell交互的工具而言，对于"ls -al …" !如下描述正确的是？C

A. 表示仅执行ls -al …命令并没有任何返回值。
B. 表示执行ls -al …命令，并返回执行的结果。
C. 表示执行ls -al …命令，并将此命令执行的退出码返回。
D. 以上描述均不正确。

84、以下关于特质的说法错误的是？C

A. 类可以实现任意数量的特质。
B. 特质可以要求实现它们的类具备特定的字段、方法或超类。
C. 与Java接口(Interface)相同，Scala特质也可以提供方法和字段的实现。
D. 当将多个特质叠加在一起时，顺序很重要——其方法先被执行的特质排在更后面。

85、关于Scala中不支持多重继承的原因描述正确的是？D

A. 在实际使用中，真正必须使用多重继承的时机很少。
B. 若多重继承的两个基类具有相同的字段或方法，就会引发菱形继承问题，造成问题的复杂性。
C. 通过使用Trait可以达到多重继承的类似效果。
D. 以上均正确。

86、关于Scala中的trait和Java中的Interface描述错误的是？A

A. Scala特质和Java接口都可以包含抽象方法和具体实现。
B. Scala和Java都不允许多重继承，但可以叠加多个特质或接口。
C. Java只能在类层面上添加接口的实现，而Scala可以在类和对象层面上“混入”特质。
D. 以上描述至少有一项有误。

87、对于Scala中混入了特质的对象，关于其在构造时构造器执行顺序的描述错误的是？C

A. 首先调用超类的构造器。
B. 特质构造器在超类构造器之后、类构造器之前执行。所有特质构造完毕，子类被构造。
C. 特质由右到左被构造。如果多个特质共有一个父特质，而那个父特质已经被构造，则不会再次构造。
D. 每个特质中，父特质先被构造。

88、对于下述代码描述错误的是？D

class MyClass
 
trait TestLog {
val testName: String
val realName = testName + ".log"
}
 
val log = new MyClass with TestLog{
val testName = "test"
}

A. log.realName并不是期望的"test.log"。
B. 可以通过val log = new MyClass {val testName = “test”;} with TestLog，来达到log.realName的值为"test.log"。
C. 可以通过将TestLog中的realName定义修改为，lazy val realName = testName + “.log”，来达到log.realName的值为"test.log"。
D. 以上描述最多有两个描述正确。

89、对于以this: 类型 =>代码开始定义的特质，描述错误的是？D

A. 此描述叫作“自身类型(self type)”，表示此特质只能被混入指定类型的子类中。
B. 在此特质的方法中，可以调用上述类型中所具有的任何方法。
C. 此类型，可以是一个方法的集合，如{def getMessage(): String}用于表示此特质可以被混入任何拥有getMessage方法的类中。
D. 以上描述最多有两个描述正确。

90、**[intermediate]**Scala将特质翻译成JVM的类和接口的描述错误的是？D

A. 只有抽象方法的特质被简单地变成一个Java接口。
B. 如果特质中包含具体方法，则Scala会帮我们创建出一个伴生类，该伴生类用静态方法存放特质的方法。
C. 特质中的字段对应到接口中的抽象的getter和setter方法。
D. 以上描述至少有一个是错误的。

91、**[intermediate]**对于一元操作符下述描述错误的是？B

A. “+”、"-"、"!"、"~“这四个操作符可以作为前置操作符，出现在参数之前。
B. 前置表达式"操作符 a”，可以表示为"a.unary_操作符(1)"。
C. 如果此操作符出现在参数之后，那么它就是一个后置操作符，如"a 操作符"。
D. 后置表达式"a 操作符"，可以表示为"a.操作符()"。

92、有关操作符优先级的描述不正确的是？C

A. *=的优先级低于+。
B. >的优先级高于&。
C. 后置操作符的优先级高于中置操作符。
D. %的优先级高于+。

93、对于f(arg1, arg2, …)描述有误的是？D

A. 若其未出现在赋值表达式的左侧，若f是函数或方法，则其只是对其的调用。
B. 若其未出现在赋值表达式的左侧，且f不是函数或方法，则其等同于f.apply(arg1, arg2, …)。
C. 若其出现在赋值表达式的左侧，如"f(arg1, arg2, …) = value"，则其等同于f.update(arg1, arg2, …, value)。
D. 以上描述至少有一个是错误的。

94、以下关于Scala中函数的描述错误的是?B

A. 函数是“头等公民”，就和数字一样。
B. 可以将函数赋值给变量，如val fun = scala.math.ceil。
C. 支持非具名函数，也即匿名函数。
D. 可以将函数作为参数，传递给其它函数。

//有参数的函数必须传参
scala> val fun = scala.math.ceil
<console>:12: error: missing argument list for method ceil in package math
Unapplied methods are only converted to functions when a function type is expected.
You can make this conversion explicit by writing `ceil _` or `ceil(_)` instead of `ceil`.
       val fun = scala.math.ceil
                            ^

95、对集(Set)进行操作"Set(2, 0, 1) + 1 + 1 - 1"之后的结果为？C

A. Set(2, 0, 1, 1)
B. Set(2, 0, 1)
C. Set(2, 0)
D. 已上均不正确。

scala> Set(2, 0, 1) + 1
res12: scala.collection.immutable.Set[Int] = Set(2, 0, 1)

scala> res12+1
res13: scala.collection.immutable.Set[Int] = Set(2, 0, 1)

scala> res13-1
res14: scala.collection.immutable.Set[Int] = Set(2, 0)

96、下述方法中，哪一个不能将"val tmp = List(1, 2, 3)"中的所有元素求和，并将最终结果6返回？D

A. tmp.foldLeft(0)(_ + )
B. tmp.reduceLeft( + )
C. (0 /: tmp)( + )
D. tmp.scanLeft(0)( + _)

97、下面有关val f: PartialFunction[Char, Int] = {case '+' => 1; case '-' => -1}的描述有误的是？D

A. f是一个偏函数，且其参数类型为Char、返回类型为Int。
B. f(’-’)的结果是返回-1。
C. f.isDefinedAt(‘0’)的结果是返回false。
D. f(‘0’)在执行时由于没有对应的case语句，故会返回一个任意Int值。

//没有匹配上会报错
scala> f('0')
scala.MatchError: 0 (of class java.lang.Character)
  at scala.PartialFunction$$anon$1.apply(PartialFunction.scala:253)
  at scala.PartialFunction$$anon$1.apply(PartialFunction.scala:251)

98、在下述代码基础上，不能正确执行的操作是？C

case class Currency(value: Double, unit: String)
val amt = Currency(29.95, "EUR")

A. amt.copy(value = 19.2)
B. amt.copy()
C. amt.copy(“CHF”)
D. amt.copy(unit = “CHF”)

传参要指定名称才行

99、**[intermediate]**对于下述代码，哪个描述是正确的？A

val one: PartialFunction[Option[Int], String] = {
case Some(_) => "one"
}

A. one.isDefinedAt(Some(1)) == true
B. one.isDefinedAt(1) == true
C. one.isDefinedAt(Some(100)) == false
D. one.isDefinedAt(None) == true

100、在对htmlText进行匹配时，应该使用哪一种case语句？B

def getHtml(url: String): Try[String] = {...}
val myUrl = "http://justtest.org"
val htmlText = getHtml(myUrl)
val result = htmlText match {
???
}

A. case Some(x) =>
　　case None(x) =>
B. case Success(v) =>
　　case Failure(e) =>
C. case String(x) =>
　　case Url(y)
D. case Try1(v) =>
　　case Try2(v) =>