1、**[primary]**关于和Scala进行交互的基本方式REPL说法错误的是? C
A、R 读取（read）
B、E 求值（evaluate）
C、P 解析（Parse）
D、L 循环（Loop）
D
A、Char
B、Int
C、Float
D、LongLong
B
A、import scala.math._
B、import sqrt
C、import math._
D、import math.sqrt
B
A、val a = 3
B、val a:String = 3
C、var b:Int = 3 ; b = 6
D、var b = "Hello World!" ; b = "123"
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)
D
A、println("Hello World")
B、print("Hello World\n")
C、printf("Hello %s", "World")
D、val w = "World" ; println("Hello $w")
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)
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")}
D
A、val a = Array[Int](0, 0)
B、val a = Array(0, 0)
C、val a = Array[Int](2)
D、val a = Array[Int](1, 1)
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
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"
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”
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无法访问， 会抛出异常
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))
C
A、“crazy”*3
B、ccrraazzyy
C、crazycrazycrazy
D、crazy
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
A、var x={}
B、var x=1
C、var x="test"
D、var x=(1,1)
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
}
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
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
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)
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)
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))
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)
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
"New York".partition(_.isUpper)返回结果正确的是？B
A、("New", "York")
B、("NY", "er ork")
C、("er ork", "NY")
D、("New York", "NY")
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
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
C
A.class Counter{def counter = “counter”}
B.class Counter{val counter = “counter”}
C.class Counter{var counter:String}
D.class Counter{def counter () {}}
B
A. var foo： Scala自动合成一个getter 和一个setter
B. val foo： Scala自动合成一个getter
C. 可以单独定义foo方法
D. 可以单独定义foo_=方法
[primary]
Class Countter(name:String){
val a = 1
var b = “counter”
}
C
A. counter.name = “cpu”
B. counter.a = 2
C. counter.b = “conter2”
D. counter.a = counter.b
B
A. 单例对象不可以定义方法，而类可以
B. 单例对象不可以带参数，而类可以
C. 单例对象不可以定义私有属性，而类可以
D. 单例对象不可以继承，而类可以
C
A. 辅助构造器的必须调用主构造器
B. 辅助构造器的可以直接调用超类的主构造器
C. 辅助构造器的参数可以是任意多个
D. 辅助构造器的名称和类名相同
A
A. 主构造器在每个类都可以定义多个
B. 主构造器的参数可以直接放在类名后。
C. 主构造器的会执行类定义中的所有语句。
D. 主构造器中可以使用默认参数。
B
A. name是对象私有字段
B. name是类私有字段，有私有的getter方法
C. name是类公有字段，有公有的getter和setter方法
D. name是类私有字段，可以在类内部被改变
C
A. scala 中， 可以在类中定义类。
B. scala 中， 可以在函数中定义函数。
C. scala 中， 不可以在类中定义object。
D. scala 中， 可以在函数中定义类。
A
A. public
B. private
C. protected
D. 以上都不对
B
A. object A{var str = “”}。
B. object A(str:String){}
C. object A{def str = “”}
D. object A{val str = “”}
A
A. 包的名称不能重复。
B. 同一个包可以定义在多个文件中。
C. 包路径不是绝对路径。
D. 包对象可以持有函数和变量。
D
A. 包和其成员可以用import
B. 可以引用某个文件夹下所有文件夹内的文件
C. 可以引用某个文件夹下的所有文件
D. 可以引用某个文件夹下单个文件
43、**[primary]**下面关于override修饰符的描述错误的是？D
A. Scala里所有重载了父类具体成员的成员都需要这样的修饰符
B. Scala里如果子类成员实现的是同名的抽象成员则这个修饰符是可选的
C. Scala里如果子类中并未重载或实现什么基类里的成员则禁用这个修饰符
D. Scala里如果子类是抽象类则子类的同名成员不可以使用这个修饰符
B
A. 类的声明上添加final修饰符确保成员不被子类重载
B. 类的声明上添加final修饰符把整个类声明为final，这个类不能被继承
C. 类的声明上添加final修饰符确保成员只能被子类重载一次
D. 以上说法都是错误的
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]()。
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
}
D
A. getter ,setter
B. getAge, setAge
C. age, age_
D. age, age_=
D
A. 辅助构造器的名称为this。
B. 辅助构造器的定义要调用已定义的辅助构造器或主构造器。
C. 辅助构造器可以有任意多个
D. 辅助构造器必须要带参数
B
A. Scala中，类内部的不是从构造器定义的代码，都会在主构造器中执行
B. Scala中，类内部的不是字段的部分或者方法定义的代码，都会在主构造器中执行
C. Scala中，类内部的所有的代码，都会在主构造器中执行
D. 以上说法都是错误的。
B
A. 类和它的伴生对象定义在同一个文件中。
B. 类和它的伴生对象可以有不同的名称。
C. 类和它的伴生对象可以互相访问私有特性。
D. 类和它的伴生对象可以实现既有实例方法又有静态方法。
A
A. apply方法返回的是伴生类的对象。
B. apply方法不可以带参数。
C. apply方法返回的是Unit。
D. apply方法定义在类里面。
D
A. 引入语句可以引入包、类和对象。
B. 引入语句可以出现在任意位置。
C. 引入语句可以重命名。
D. 引入语句不可以隐藏特定成员。
A
class Cat extends Animal{}
A. Cat是Animal的子类。
B. Animal是Cat的子类
C. Cat是Animal的超类
D. Animal一定是抽象类
A
A. scala 中，使用extends进行类的扩展。
B. scala 中, 声明为final的类可以被继承。
C. scala中，超类必须是抽象类。
D. scala中，抽象类可以被实例化。
B
A. Scala里，字段和方法属于相同的命名空间。
B. Scala一共有四个命名空间。
C. Scala里，字段可以重载无参数方法。
D. Scala类和特质属于相同的命名空间。
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
C
abstract class Element
{
def contents: Array[String]
}
A. Element是一个抽象类。
B. Element不能实例化。
C. Contents成员定义错误，没有初始化。
D. contents方法是类Element的抽象成员。
D
A. scala中，Float是Double的子类。
B. scala中，Int是Long的子类。
C. scala中，Double是AnyRef的子类
D. scala中，Long是AnyVal的子类
59、**[intermediate]**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
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
}
A
A. 在使用完此Source对象后，需要调用close方法来释放相关资源。
B. 可以使用此Source对象向其指定的文件中写入内容。
C. 可以修改此Source对象所指定的文件名称。
D. 以上说法均不正确。
B
A. .
B. ?
C. *
D. +
D
A. .
B. ?
C. *
D. +
C
A. "\s+[0-9]+\s+".r
B. ""\s+[0-4]+\s+".r
C. """\s+\d+\s+""".r
D. 以上均不正确。
C
A. `type`
B. |>
C. 2K
D. hello
B
A. 其中的“操作符”代表一个带有两个参数的方法(一个隐式的参数和一个显式的参数)。
B. 中置表达式，一定可以提高代码的可阅读性。
C. Scala在当方法只有一个参数时，可以省略点号、以及括号，从而形式上变成中置表达式。
D. 可以将此中置表达式修改为"a.操作符(b)"。
D
A. 操作符的结合性决定了它们是从左到右求值还是从右到左求值。
B. |操作符是左结合的。
C. 以冒号结尾的操作符是右结合的。
D. 赋值操作符是左结合的。
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. 以上描述全部错误。
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
A. 柯里化是指将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数作为参数的函数。
B. 有时，使用柯里化将某个函数参数单拎出来，可以提供更多用于类型推断的信息。
C. 将函数def add(x: Int, y: Int) = x + y，变形为def add(x: Int)(y: Int) = x + y的过程是一个柯里化过程。
D. 柯里化是多参数列表函数的特例。
C
A. 在程序中应该首先被定义的函数。
B. 将函数作为参数，并返回结果为函数的函数。
C. 函数参数为函数或返回结果为函数的函数。
D. 执行时间长的函数。
B
A. def functionOne(x: Int)
B. def functionOne(x: => Int)
C. def functionOne(x: -> Int)
D. def functionOne(x: Name)
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
A
A. 列表(List)
B. 序列(Seq)
C. 集(Set)
D. 映射(Map)
D
A. Set是一组没有先后次序的值。
B. Map是一组(键，值)对偶。
C. 每个Scala集合特质或类都有一个带有apply方法的伴生对象，可以用此方法来构建该集合中的实例。
D. 为了顾及安全性问题，Scala仅支持不可变集合而不支持可变集合。
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
A
A. 默认情况下可对其属性进行修改。
B. 在模式匹配时会进行解构操作。
C. 两个case class进行比较时进行全等比较，而非按是否引用同一个对象进行比较。
D. 相比于class而言更简洁的实例化过程(不需要使用new操作符)及其它操作语法。
D
A. 若样例类的通用超类声明为sealed，则在使用样例类来做模式匹配时，编译器可以确保你已经列出了所有可能的选择。
B. 对于用sealed声明的类，其子类必须与其处于同一个文件中。
C. 声明为sealed的类可以有效防止继承滥用。
D. 声明为sealed的类由于是密封的，故不能对此类中实现的方法在子类中进行修改。
C
A. Option类型可以用来表示那种可能存在、也可能不存在的值。
B. Option类型的两种状态分别是Some和None。
C. Option类型的两种状态分别是Success和Failure。
D. 可以使用isEmpty方法来判断是否存在值。
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)是一个守卫表达式。
C
A. 可以使用指定文件名(String)来创建一个Source
B. 可以使用一个文件的URI(java.net.URI)来创建一个Source
C. 可以使用一个文件的URL(java.net.URL)来创建一个Source
D. 可以使用一个File对象(java.io.File)来创建一个Source
D
A. 可以直接使用scala的库来读取二进制文件。
B. 可以直接使用scala的库来写入文件文件。
C. 在读取文件时，如果不指定文件编码格式则scala会推断出正确的格式进行读取。
D. 以上描述均不正确。
"ls -al .." !如下描述正确的是？C
A. 表示仅执行ls -al ..命令并没有任何返回值。
B. 表示执行ls -al ..命令，并返回执行的结果。
C. 表示执行ls -al ..命令，并将此命令执行的退出码返回。
D. 以上描述均不正确。
C
A. 类可以实现任意数量的特质。
B. 特质可以要求实现它们的类具备特定的字段、方法或超类。
C. 与Java接口(Interface)相同，Scala特质也可以提供方法和字段的实现。
D. 当将多个特质叠加在一起时，顺序很重要——其方法先被执行的特质排在更后面。
D
A. 在实际使用中，真正必须使用多重继承的时机很少。
B. 若多重继承的两个基类具有相同的字段或方法，就会引发菱形继承问题，造成问题的复杂性。
C. 通过使用Trait可以达到多重继承的类似效果。
D. 以上均正确。
A
A. Scala特质和Java接口都可以包含抽象方法和具体实现。
B. Scala和Java都不允许多重继承，但可以叠加多个特质或接口。
C. Java只能在类层面上添加接口的实现，而Scala可以在类和对象层面上“混入”特质。
D. 以上描述均错误。
C
A. 首先调用超类的构造器。
B. 特质构造器在超类构造器之后、类构造器之前执行。所有特质构造完毕，子类被构造。
C. 特质由右到左被构造。如果多个特质共有一个父特质，而那个父特质已经被构造，则不会再次构造。
D. 每个特质中，父特质先被构造。
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. 以上描述最多有两个描述正确。
this: 类型 =>代码开始定义的特质，描述错误的是？D
A. 此描述叫作“自身类型(self type)”，表示此特质只能被混入指定类型的子类中。
B. 在此特质的方法中，可以调用上述类型中所具有的任何方法。
C. 此类型，可以是一个方法的集合，如{def getMessage(): String}用于表示此特质可以被混入任何拥有getMessage方法的类中。
D. 以上描述最多有两个描述正确。
D
A. 只有抽象方法的特质被简单地变成一个Java接口。
B. 如果特质中包含具体方法，则Scala会帮我们创建出一个伴生类，该伴生类用静态方法存放特质的方法。
C. 特质中的字段对应到接口中的抽象的getter和setter方法。
D. 以上描述至少有一个是错误的。
B
A. "+"、"-"、"!"、"~"这四个操作符可以作为前置操作符，出现在参数之前。
B. 前置表达式"操作符 a"，可以表示为"a.unary_操作符(1)"。
C. 如果此操作符出现在参数之后，那么它就是一个后置操作符，如"a 操作符"。
D. 后置表达式"a 操作符"，可以表示为"a.操作符()"。
C
A. *=的优先级低于+。
B. >的优先级高于&。
C. 后置操作符的优先级高于中置操作符。
D. %的优先级高于+。
f(arg1, arg2, ...)描述有误的是？D
A. 若其未出现在赋值表达式的左侧，若f是函数或方法，则其只是对其的调用。
B. 若其未出现在赋值表达式的左侧，且f不是函数或方法，则其等同于f.apply(arg1, arg2, ...)。
C. 若其出现在赋值表达式的左侧，如"f(arg1, arg2, ...) = value"，则其等同于f.update(arg1, arg2, ..., value)。
D. 以上描述至少有一个是错误的。
B
A. 函数是“头等公民”，就和数字一样。
B. 可以将函数赋值给变量，如val fun = scala.math.ceil。
C. 支持非具名函数，也即匿名函数。
D. 可以将函数作为参数，传递给其它函数。
C
A. Set(2, 0, 1, 1)
B. Set(2, 0, 1)
C. Set(2, 0)
D. 已上均不正确。
D
A. tmp.foldLeft(0)(_ + _)
B. tmp.reduceLeft(_ + _)
C. (0 /: tmp)(_ + _)
D. tmp.scanLeft(0)(_ + _)
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值。
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")
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
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) =>
