scala习题精选100道解答
scala习题精选100道
1、关于和Scala进行交互的基本方式REPL说法错误的是? C
A、R 读取（read）
B、E 求值（evaluate）
C、P 解析（Parse）
D、L 循环（Loop）
P不是解析，而是表示打印Print
2、不属于Scala7种数值类型的是? D
A、Char
B、Int
C、Float
D、LongLong
只有Long，没有longlong，scala支持的数据类型如下
Byte 8位有符号补码整数。数值区间为 -128 到 127
Short 16位有符号补码整数。数值区间为 -32768 到 32767
Int 32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long 64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807，可以加L或l后缀
Float 32位IEEE754单精度浮点数，可以加F或f后缀
Double 64位IEEE754单精度浮点数
Char 16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String 字符序列
Boolean true或false，注意这里是小写
Unit 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null null 或空引用
Nothing Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。
Any Any是所有其他类的超类
AnyRef AnyRef类是Scala里所有引用类(reference class)的基类
3、如果需要使用scala库中的sqrt函数,如sqrt(2)，下列引用包的方式错误的是? B
A、import scala.math._
B、import sqrt
C、import math._
D、import math.sqrt
导入库时候scala可以省略，但是下一级就不能再省略。默认情况下，Scala 总会引入 java.lang._ 、 scala._ 和 Predef._，这里也能解释，为什么以scala开头的包，在使用时都是省去scala.的。
4、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"
虽然scala会自己解析类型，但3这种明显不是string类型
5、在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)
应该是"Hello"(0)，"Hello"(4)
"Hello".take(1)表示取左边开始1个字符，2表示取2个
Reverse表示取反，然后(0)表示头一个，
6、下面输出与其他不一致的是？D
A、println("Hello World")
B、print("Hello World\n")
C、printf("Hello %s", "World\n")
D、val w = "World" ; println("Hello $w")
val w = "World" ; println(s"Hello $w")才能打印正确
7、关于函数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)
Sum是求和功能，所以D不一致; Scala允许你指明函数的最后一个参数可以是重复的，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表。Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)
8、下列表达式不是过程的是？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")}
C是单纯取值，其他有打印的过程
9、下列数组定义与其他不一致的是？D
A、val a = Array[Int](0, 0)
B、val a = Array(0, 0)
C、val a = new Array[Int](2)
D、val a = Array[Int](1, 1)
D是初始化为(1,1),其他都是初始化为(0,0)
10、下列关于数组缓冲val b = ArrayBuffer[Int]()操作结果的注释说明错误的是？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)
应该为b ++= Array(1,2),scala中++=常用于对更大等级数据，比如
val buf = new StringBuilder;
buf += 'a'
buf ++= "bcdef"
11、关于数组的常用算法，下列说法错误的是？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"
Sort是按递增排序，字符串求序是按字典序，mkString是把集合转成字符串，可以带一个分隔符参数
12、关于元组 Tuple 说法错误的是？D
A、元组的可以包含不同类型的元素
B、元组是不可变的
C、访问元组第一个元素的方式为 pair._1
D、元组最多只有2个元素
集合类通过_访问，是从1开始
Scala设计元组最多可以支持到22个元素
13、对于函数
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”
因为没有sock，所以getOrElse就走到0
14、对于元组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无法访问， 会抛出异常
t_1缺了小数点如t._1，或者需要空格t _1
String是从java导入，不是scala自带的
val (first, second, _) = t也是一种模式匹配,对比_方式可读性更好
t._0返回空，不会异常
15、对于拉链操作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))
也可以写成t1 zip t2
16、Scala允许你用数字去乘字符串—去REPL中试一下"crazy"*3。这个操作结果返回什么？C
A、”crazy”*3
B、ccrraazzyy
C、crazycrazycrazy
D、crazy
反过来则不行，3*”crazy”
17、下面选项中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
其他选项中a类型都是Int，B中a的类型是Double
18、指出在Scala中何种情况下赋值语句x=y=1是合法的？A
A、var x={}
B、var x=1
C、var x="test"
D、var x=(1,1)
知识点暂未明确
19、编写一个过程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
}
了解to和until区别，until是没到，to是达到，
20、表达式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
J跳过和I相同的数字，然后打印组成的2位数
21、关于函数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、关于函数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)
打印出xx, “x”是x的缺省参数，0是y的缺省参数
23、关于数组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)
B考察map用法，一一映射
C考察yield的用法，数组生成数组
D中只有一个2%2==0，所以得到2*2=4，并且类型是数组
24、关于数组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、对于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)
对value映射成新值
26、对于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
虽然val map是不可改，但B中的(prices + ("shoes" -> 30))("shoes")相当于一个新map，C同理，在D中，对于不存在的key, 会抛出NoSuchElementException异常
27、对于表达式"New York".partition(_.isUpper)返回结果正确的是？B
A、("New", "York")
B、("NY", "er ork")
C、("er ork", "NY")
D、("New York", "NY")
partition的作用是将满足条件的分一组，不满足的分到另一组
和partition相似的是span，但有不同：
List(1,9,2,4,5).span(_<3) // (List(1),List(9, 2, 4, 5))，碰到不符合就结束
List(1,9,2,4,5).partition(_<3) // (List(1, 2),List(9, 4, 5))，扫描所有
28、对于表达式
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
该段代码的功能是统计每个以空格分隔的单词的数量，getOrElse（key,0）的意思是如果不存在该key，则使用0值，这样可以使得无论key是否已经在map中，都可以正常加1。
29、编写一个函数，返回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)
}
A默认的返回值类型为Unit, 可修改成def maxmin(nums:Array[Int])= …或def maxmin(nums:Array[Int]) : (Int, Int)=…返回元组
B “->“将产生一个元组返回
C 编译错误，不能使用，连接
D返回的是最小和最大值，不是最大和最小值，顺序不符要求
30、对于拉链操作
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
zip函数将传进来的两个参数中相应位置上的元素组成一个pair数组。如果其中一个参数元素比较长，那么多余的参数会被删掉。zip后产生Array((1,”one”),(2,”two”)
31、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 () {}}
A的写法相当于定义一个叫counter的方法，其返回值就是字符串值，B是定义一个成员，D是定义一个方法；C错，scala不同于java会自动赋值，需要对声明的变量赋值，否则，要声明成抽象类。可改为var counter:String=_
32、scala的类在实现属性时，下面说法中错误的是？B
A. var foo： Scala自动合成一个getter 和一个setter
B. val foo： Scala自动合成一个getter 和一个setter
C. 可以单独定义foo方法
D. 可以单独定义foo_=方法
B选项错误，对于val不可变类型，编译器只会生成getter方法
Scala对setter和getter的控制：如果字段是私有的，则getter和setter方法也是私有的；如果字段是val，则只有getter方法被生成；如果你不需要任何getter和setter，可以将字段声明为private[this]；总结，在实现属性时有如下四种选择：var foo:Scala自动合成一个getter和setter；val foo:Scala自动合成getter；由你来定义foo和foo_=方法；由你来定义foo方法；
33、定义类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 = “conter”
D. counter.a = counter.b
counter.b=“counter”, counter.name不存在，不是成员变量
34、类和单例对象间的差别是？B
A. 单例对象不可以定义方法，而类可以
B. 单例对象不可以带参数，而类可以
C. 单例对象不可以定义私有属性，而类可以
D. 单例对象不可以继承，而类可以
Class可带参数来初始化，object没有初始化参数，如下所示
Object some_obj{ ……
Class some_class(Int x, Int y){….
35、关于辅助构造器，以下说法正确的是？C
A. 辅助构造器的必须调用主构造器
B. 辅助构造器的可以直接调用超类的主构造器
C. 辅助构造器的参数可以是任意多个
D. 辅助构造器的名称和类名相同
和java或c++一样，scala也可以有任意多的构造器。不过，scala类有一个构造器比其它所有构造器都更为重要，它就是主构造器。除了主构造器之外，类还可以有任意多的辅助构造器。D选项错误，辅助构造器的名称为this。A、B错误，每一个辅助构造器都必须以一个对先前已定义的其它辅助构造器或主构造器的调用开始
36、关于主构造器，以下说法错误的是？A
A. 主构造器在每个类都可以定义多个
B. 主构造器的参数可以直接放在类名后。
C. 主构造器的会执行类定义中的所有语句。
D. 主构造器中可以使用默认参数。
主构造器是在类声明处，只可能有一个
37、定义类 Class Person（private val name: String）{},以下说法正确是？B
A. name是对象私有字段
B. name是类私有字段，有私有的getter方法
C. name是类公有字段，有公有的getter和setter方法
D. name是类私有字段，可以在类内部被改变
这里不是对象，A中描述不正确
类中定义的为类变量，private访问修饰符说明为私有变量，val在编译时会生成getter方法
38、scala 中，以下说法错误是？C
A. scala 中， 可以在类中定义类。
B. scala 中， 可以在函数中定义函数。
C. scala 中， 不可以在类中定义object。
D. scala 中， 可以在函数中定义类。
可以嵌套定义
39、scala 中，类成员的缺省访问级别是？A
A. public
B. private
C. protected
D. 以上都不对
用private关键字修饰，带有此标记的成员仅在包含了成员定义的类或对象内部可见
在 scala 中，保护（Protected）成员只允许保护成员在定义了该成员的的类的子类中被访问
40、以下单例对象，定义错误的是？B
A. object A{var str = ““}。
B. object A(str:String){}
C. object A{def str = ““}
D. object A{val str = ““}
B,单例对象不能携带构造参数,Class才可以带
41、scala中，关于包的说法不正确的是？A
A. 包的名称不能重复。
B. 同一个包可以定义在多个文件中。
C. 包路径不是绝对路径。
D. 包对象可以持有函数和变量。
A选项不清晰，相同包名可以重复import，也不会错误
根据Scala”一切皆对象”设计哲学，包(package)也是一种对象。既然是对象，那么就应该有属性和方法，也可以在包对象内声明某个类型的别名。包的要点：
1. 包也可以像内部类那样嵌套
2. 包路径不是绝对路径
3. 包声明链x.y.z并不自动将中间包x和x.y变成可见
4. 位于文件顶部不带花括号的包声明在整个文件范围内有效
5. 包对象可以持有函数和变量
6. 引入语句可以引入包、类和对象
7. 引入语句可以出现在任何位置
8. 引入语句可以重命名和隐藏特定成员
9. java.lang、scala和Predef总是被引入
42、scala中，关于包的引用错误的是？D
A. 包和其成员可以用import
B. 可以引用某个文件夹下的特定文件
C. 可以引用某个文件夹下的所有文件
D. 包引用只能在编译单元的开始处
可以在任何处，也就是使用时引用
43、下面关于override修饰符的描述错误的是？D
A. Scala里所有重载了父类具体成员的成员都需要这样的修饰符
B. Scala里如果子类成员实现的是同名的抽象成员则这个修饰符是可选的
C. Scala里如果子类中并未重载或实现什么基类里的成员则禁用这个修饰符
D. Scala里如果子类是抽象类则子类的同名成员不可以使用这个修饰符
scala对抽象类继承时，子类对父类的方法不用override，直接可以进行修改。对抽象字段也不用override
44、Scala里，final修饰符的描述正确的是？B
A. 类的声明上添加final修饰符确保成员不被子类重载
B. 类的声明上添加final修饰符把整个类声明为final，这个类不能被继承
C. 类的声明上添加final修饰符确保成员只能被子类重载一次
D. 以上说法都是错误的
声明成final的类不能继承。 如果定义了一个类为final类，那就不能进一步扩展了
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]()。
因为是单引号，所以应该为List[Char]
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
}
A, 类构造器的参数类型不能省略
B, name需声明成 var 或val
C, scala中无public关键字，没有其他返回修饰符默认就是public的作用，写了反而编译不过
47、Scala类中的公有字段自带getter和setter，类class Persen{var age=0} ，age字段默认定义的方法是？D
A. getter ,setter
B. getAge, setAge
C. age, age_
D. age, age_=
age的自带的方法为age(), age_=(xx:Int)
48、关于辅助构造器，以下说法不正确的是？D
A. 辅助构造器的名称为this。
B. 辅助构造器的定义要调用已定义的辅助构造器或主构造器。
C. 辅助构造器可以有任意多个
D. 辅助构造器必须要带参数
可以不需要
49、Scala中的类，以下说法正确的是？B
A. Scala中，类内部的不是从构造器定义的代码，都会在主构造器中执行
B. Scala中，类内部的不是字段的部分或者方法定义的代码，都会在主构造器中执行
C. Scala中，类内部的所有的代码，都会在主构造器中执行
D. 以上说法都是错误的。
一个Scala类里面，除了方法和字段的定义以外的代码，全都是主构造器的内容。
50、scala 中，类和它的伴生对象说法错误的是？B
A. 类和它的伴生对象定义在同一个文件中。
B. 类和它的伴生对象可以有不同的名称。
C. 类和它的伴生对象可以互相访问私有特性。
D. 类和它的伴生对象可以实现既有实例方法又有静态方法。
伴生对象要求同名
51、关于对象的apply方法，正确的是？A
A. apply方法返回的是伴生类的对象。
B. apply方法不可以带参数。
C. apply方法返回的是Unit。
D. apply方法定义在类里面。
apply方法可以带参数，返回的是对象，定义在类的伴生对象中
52、scala中，关于引入语句的说法不正确的是？D
A. 引入语句可以引入包、类和对象。
B. 引入语句可以出现在任意位置。
C. 引入语句可以重命名。
D. 引入语句不可以隐藏特定成员。
可以隐藏 方法=>_，例：import java.util.{HashMap =>_ , _}
53、对于下述代码说法正确的是？A
class Cat extends Animal{}
A. Cat是Animal的子类。
B. Animal是Cat的子类
C. Cat是Animal的超类
D. Animal一定是抽象类
Cat继承Animal类，Cat是Animal的子类，Animal是Cat的父类
54、scala中的类，下面说法正确的是？A
A. scala 中，使用extends进行类的扩展。
B. scala 中, 声明为final的类可以被继承。
C. scala中，超类必须是抽象类。
D. scala中，抽象类可以被实例化。
B存疑
D中，不能实例化抽象类
55、scala中，下列描述错误的是？B
A. Scala里，字段和方法属于相同的命名空间。
B. Scala一共有四个命名空间。
C. Scala里，字段可以重载无参数方法。
D. Scala类和特质属于相同的命名空间。
Scala里的字段和方法属于相同的命名空间，所以可以使用字段来重写无参数方法,所以，Scala禁止在同一个类里用同样的名称定义字段和方法
不同于Java（4个命名空间）,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
类 ArrayElement拥有一个可以从类外部访问的，（不能重新赋值的）字段contents。字段使用参数值 初始化
57、类定义如下，描述不正确的是？C
abstract class Element
{
def contents: Array[String]
}
A. Element是一个抽象类。
B. Element不能实例化。
C. Contents成员定义错误，没有初始化。
D. contents方法是类Element的抽象成员。
Element是抽象类，不能被实例化，Contents为定义不完全的方法
58、scala语言中，下面描述正确的是？D
A. scala中，Float是Double的子类。
B. scala中，Int是Long的子类。
C. scala中，Double是AnyRef的子类
D. scala中，Long是AnyVal的子类
Boolean,Byte,Char,Double,Float,Int,Long,Short,Unit都为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
:: 该方法被称为cons，意为构造，向队列的头部追加数据
::: 该方法只能用于连接两个List类型的集合
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
}
知识点暂未明确
61、对于由scala.io.Source.fromFile创建的Source对象的使用以下描述正确的是？A
A. 在使用完此Source对象后，需要调用close方法来释放相关资源。
B. 可以使用此Source对象向其指定的文件中写入内容。
C. 可以修改此Source对象所指定的文件名称。
D. 以上说法均不正确。
该类操作只能读，读完要close，不能修改名称
62、在正则表达式中，如下哪个符号用于匹配单个字符？B
A. .
B. ?
C. *
D. +
. 匹配除"\r\n"之外的任何单个字符
? 重复零次或一次
* 重复零次或更多次
+重复一次或更多次
63、在正则表达式中，如下哪个符号用于匹配一次或多次？D
A. .
B. ?
C. *
D. +
参考63
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
`type`：反引号标识符
|>：编码在\u0020到\u007F之间的字符（如数学符号）
2k:普通标识符，由字母和下划线开头
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是一个闭包。
D没有非局部变量
70、有关柯里化描述错误的是？D
A. 柯里化是指将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数作为参数的函数。
B. 有时，使用柯里化将某个函数参数单拎出来，可以提供更多用于类型推断的信息。
C. 将函数def add(x: Int, y: Int) = x + y，变形为def add(x: Int)(y: Int) = x + y的过程是一个柯里化过程。
D. 柯里化是多参数列表函数的特例。
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 = someCurring(4)(3)
A. 6
B. 4
C. 8
D. 9
柯里化：x=4,y=3,得到结果2*3=6
74、集合可以分为三大类，以下描述中不是这三大类的是？A
A. 列表(List)
B. 序列(Seq)
C. 集(Set)
D. 映射(Map)
List,Queue,Stack等都为Seq？的子类
75、以下对集合的描述有误的是？D
A. Set是一组没有先后次序的值。
B. Map是一组(键，值)对偶。
C. 每个Scala集合特质或类都有一个带有apply方法的伴生对象，可以用此方法来构建该集合中的实例。
D. 为了顾及安全性问题，Scala仅支持不可变集合而不支持可变集合。
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
toUpperCase是针对字符串，另外一个是针对字符，yield会分别存储每次循环的值，最后返回。因为返回集合的类型与被遍历的集合类型是一致的，所以D选项两次遍历，最后存的是单个字母拆开的list，即List(P, E, T, T, E, R, P, A, U, L, M, A, R, Y)
77、以下关于case class描述有误的是？A
A. 默认情况下可对其属性进行修改。
B. 在模式匹配时会进行解构操作。
C. 两个case class进行比较时进行全等比较，而非按是否引用同一个对象进行比较。
D. 相比于class而言更简洁的实例化过程(不需要使用new操作符)及其它操作语法。
case class的类参数在不指定val/var修饰时，会自动编译为val，即对外只读，如果需要case class的字段外部可写，可以显式地指定var关键字
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方法来判断是否存在值。
Option[T] 是一个类型为 T 的可选值的容器： 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None 。
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)是一个守卫表达式。
循环条件if(k > 1)排除了 1 -> "One"，所以不会被yield存起来
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
scala.io.Source 查看API的fromFile方法，参数中未定义使用URL来创建Source
82、对于在scala中文件相关操作描述正确的是？D
A. 可以直接使用scala的库来读取二进制文件。
B. 可以直接使用scala的库来写入文件文件。
C. 在读取文件时，如果不指定文件编码格式则scala会推断出正确的格式进行读取。
D. 以上描述均不正确。
- Scala没有读取二进制文件的库，需要使用java的FileInputSteam
- 同上，使用FileWriter
- 不传文件编码格式，则使用平台默认编码格式，不会自动推断正确格式
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. 当将多个特质叠加在一起时，顺序很重要——其方法先被执行的特质排在更后面。
C java接口不提供方法实现
85、关于Scala中不支持多重继承的原因描述正确的是？D
A. 在实际使用中，真正必须使用多重继承的时机很少。
B. 若多重继承的两个基类具有相同的字段或方法，就会引发菱形继承问题，造成问题的复杂性。
C. 通过使用Trait可以达到多重继承的类似效果。
D. 以上均正确。
知识点暂未明确
86、关于Scala中的trait和Java中的Interface描述错误的是？A
A. Scala特质和Java接口都可以包含抽象方法和具体实现。
B. Scala和Java都不允许多重继承，但可以叠加多个特质或接口。
C. Java只能在类层面上添加接口的实现，而Scala可以在类和对象层面上”混入”特质。
D. 以上描述至少有一项有误。
java接口不提供方法实现
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. 以上描述最多有两个描述正确。
- trait TestLog初始化时已定义 val常量 realName，为null.log
- with TestLog应该放在new class后面，否则编译不过
- lazy 延迟加载初始化，只有在用到的时候初始化，故可得到test.log
89、对于以this: 类型 =>代码开始定义的特质，描述错误的是？D
A. 此描述叫作”自身类型(self type)”，表示此特质只能被混入指定类型的子类中。
B. 在此特质的方法中，可以调用上述类型中所具有的任何方法。
C. 此类型，可以是一个方法的集合，如{def getMessage(): String}用于表示此特质可以被混入任何拥有getMessage方法的类中。
D. 以上描述最多有两个描述正确。
知识点暂未明确
90、Scala将特质翻译成JVM的类和接口的描述错误的是？D
A. 只有抽象方法的特质被简单地变成一个Java接口。
B. 如果特质中包含具体方法，则Scala会帮我们创建出一个伴生类，该伴生类用静态方法存放特质的方法。
C. 特质中的字段对应到接口中的抽象的getter和setter方法。
D. 以上描述至少有一个是错误的。
知识点暂未明确
91、对于一元操作符下述描述错误的是？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. 可以将函数作为参数，传递给其它函数。
知识点暂未明确
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. 已上均不正确。
Set不可重复，+1为将对象1添加到set中，-1为set去掉1这个对象
96、下述方法中，哪一个不能将"val tmp = List(1, 2, 3)"中的所有元素求和，并将最终结果6返回？D
A. tmp.foldLeft(0)(_ + _)
B. tmp.reduceLeft(_ + _)
C. (0 /: tmp)(_ + _)
D. tmp.scanLeft(0)(_ + _)
scanLeft为累加函数，计算结果为List(0,0+1,0+1+2,0+1+2+3) List(0, 1, 3, 6)
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值。
未匹配到会报错
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、对于下述代码，哪个描述是正确的？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) =>
知识点暂未明确