spark数据处理练习题详解【上】

1. (单选题) scala中属于序列的可变的集合，可以添加，删除元素的是（）

A.Array

B.List

C.Tuple

D.ListBuffer

答案及解析：D

在Scala中，属于序列的可变集合，可以添加和删除元素的是：

D. ListBuffer

解释：

ListBuffer是Scala中mutable包下的可变序列集合
它允许高效地添加和删除元素
可以通过+=, ++=等操作添加元素，通过-=, --=等操作删除元素
它实现了Buffer接口，是mutable.Seq的子类

其他选项分析：

A (Array)：虽然是可变的，但不能改变大小，只能修改元素值
B (List)：是不可变的序列，不能直接修改内容
C (Tuple)：是不可变的，且不是序列类型

2. (单选题)var map1:Map[___________]=Map()

map1+=("tom"->21)

请填空

A.T

B.String->Int

C.String,Int

D.String=>Int

答案及解析：C

解释：

Scala中Map的类型声明格式为Map[KeyType,ValueType]
从map1+=("tom"->21)可以看出，键是字符串类型("tom")，值是整数类型(21)
因此类型应该是Map[String,Int]

其他选项分析：

A (T)：这是泛型参数标记，不是具体的类型声明
B (String->Int)：这是键值对创建语法，不是类型声明语法
D (String=>Int)：这是函数类型声明，表示从String到Int的函数映射

3. (单选题)

val tb1=("1号窗口","豆腐脑",2.5)

//为了输出1号窗口。请填空

println(tb1.________)

A._1

B._0

C._2

D._3

答案及解析：A

解释：

元组tb1的第一个元素是"1号窗口"，使用tb1._1访问
第二个元素"豆腐脑"使用tb1._2访问
第三个元素2.5使用tb1._3访问

其他选项错误原因：

B (_0)：Scala元组没有_0，索引从1开始
C (_2)：这会访问第二个元素"豆腐脑"
D (_3)：这会访问第三个元素2.5

4. (单选题)

函数调用语句为

println(mysum(3,5,2,5,1,9))

那么补充完整函数的定义

def mysum(list1:______)={

var s=0

for(i<-list1)

s=s+i

}

A.Int

B.Array[Int]

C.List[Int]

D.Int*

答案及解析：D

解释：

Int* 表示接收任意数量的Int类型参数
这种语法称为可变参数列表(varargs)
在函数内部，list1会被当作一个Seq[Int]类型的集合处理
这样函数就能接收mysum(3,5,2,5,1,9)这样的多参数调用
for循环可以遍历这个参数序列，计算所有值的总和

5. (单选题)

val set1=Set(1,2,3)

val set2=Set(2,3,4)

println(set1++set2)//并集

println(set1--set2)//差集

输出结果为

A.Set(1, 2, 3, 4)

Set(1)

B.Set(1, 2, 3, 4)

Set(2，3)

C.Set(1, 2, 3, 2，3，4)

Set(1)

D.Set(1, 2, 3, 4)

Set(1，4)

答案及解析：A

解释：

并集操作 (set1 ++ set2):
- 将两个集合的所有元素合并，去除重复元素
- set1有元素 1,2,3
- set2有元素 2,3,4
- 合并后为 Set(1, 2, 3, 4)
差集操作 (set1 -- set2):
- 返回在set1中但不在set2中的元素
- set1中的2,3也出现在set2中
- 只有1是set1独有的元素
- 所以结果为 Set(1)

其他选项错误原因：

B选项的差集结果不正确
C选项的并集包含重复元素，违背了Set的特性
D选项的差集错误地包含了4，而4不在set1中

6. (单选题)

一个酒店有100个房间，房间门都是关闭的，房间号为1~100.有100个人，编号1~100，他们经过这些房间的走廊，每个人经过时都把自己编号倍数的房间门做相反操作。问最后哪些门是开着的。

for(i<-1 to 100){

var door=false;

for(p<-1 to 100)

if(_________________)

if(door)

println(i)

}

A.i%p!=0

door= !door

B.i%p==0

door= ~door

C.i//p==1

door= !door

D.i%p==0

door= !door

答案及解析：D

解释：

条件i%p==0表示：当门号(i)能被人的编号(p)整除时，该人会操作这个门
操作door= !door表示：将门的状态取反(关变开，开变关)

完整代码应该是：

Scala 复制代码

for(i <- 1 to 100) {
  var door = false;  // 初始所有门都是关闭的
  for(p <- 1 to 100)
    if(i % p == 0)   // 如果门号能被人编号整除
      door = !door   // 改变门的状态
  if(door)
    println(i)       // 打印开着的门号
}

分析结果：

最终开着的门将是：1, 4, 9, 16, 25, 36, 49, 64, 81, 100
这些都是完全平方数
这是因为只有完全平方数的因子数量是奇数，其他数字的因子数量都是偶数
门被翻转奇数次则最终为开，被翻转偶数次则最终为关

7. (单选题)

关于单行函数正确的写法有（）

1 def f1(a:Int,b:Int):Int={return a+b}

2 def f1(a:Int,b:Int):Int={a+b}

3 def f1(a:Int,b:Int):Int=a+b

A.1，2

B.仅1

C.1，3

D.1，2, 3

答案及解析：D

带return关键字的完整形式

Scala 复制代码

def f1(a:Int, b:Int):Int = {return a+b}

这是传统的函数定义方式，使用花括号和显式的return关键字。

2.无return的块表达式形式

Scala 复制代码

def f1(a:Int, b:Int):Int = {a+b}

在Scala中，函数体中最后一个表达式的值会自动作为返回值，不需要显式的return语句。

3.简化形式

Scala 复制代码

def f1(a:Int, b:Int):Int = {a+b}

对于只有单个表达式的函数体，可以省略花括号，直接使用等号连接表达式。

8. (单选题)

println(func1("jerry",(s:String)=>{"hello "+s}))

//输出结果为hello jerry,请填空

def func1(s:String,fp:______________)={

}

A.(String=>String)

fp(s)

B.(String=>String)

println(s)

C.(String=>Unit)

fp(s)

D.(String<-String)

答案及解析：A

解释：

函数参数类型：
- fp: (String=>String) 表示fp是一个函数类型参数
- 这个函数接收一个String类型参数并返回一个String类型结果
- 正好匹配了传入的(s:String)=>{"hello "+s}这个匿名函数
函数体：
- fp(s) 将字符串s作为参数传递给fp函数
- 当fp是(s:String)=>{"hello "+s}时，结果就是"hello jerry"

其他选项错误原因：

B：函数体错误，直接打印s而不是应用函数fp
C：函数类型错误，String=>Unit表示不返回值的函数
D：语法错误，函数类型写法不正确，且函数体没有应用参数

9. (单选题)

func4(Array("tom","jerry","mike"),Array(f1,f2))

def func4(a:Array[String],fps:______________________)={

for(fp<-fps)

for(i<-a)

println(fp(i))

}

def f1(s:String)={

"welcome "+s

}

def f2(s:String)={

"hello "+s

}

A.Array[String=>String]

B.Array[s:String=>String]

C.Array[s:String=>Unit]

D.(String=>String)

答案及解析：A

解释：

函数分析：
- f1和f2都是接收一个String参数并返回String类型的函数
- 例如：f1("tom") 会返回 "welcome tom"
类型说明：
- Array[String=>String] 表示"字符串到字符串函数"的数组类型
- 这正好符合Array(f1, f2)的类型，因为f1和f2都是String=>String
函数运行流程：
- 外层循环遍历每个函数（f1, f2）
- 内层循环遍历每个字符串（"tom", "jerry", "mike"）
- 对每个组合应用函数并打印结果
- 所以会打印出6行结果（welcome tom, welcome jerry, welcome mike, hello tom, hello jerry, hello mike）

其他选项错误原因：

B：语法错误，类型声明中不应包含参数名
C：语法错误且返回类型不匹配，f1和f2返回String而非Unit
D：这是单个函数的类型，不是函数数组的类型

10. (单选题)

var s2="hello tom,hello T3m,team"

var p2="(T|t)[a-z]+m".r()

p2.findAllIn(s2).foreach(println(_))

输出结果是（）

A.tom

T3m

team

B.tom

T3m

C.T3m

team

D.tom

team

答案及解析：D

解释：

让我们分析正则表达式 (T|t)[a-z]+m 的含义：

(T|t) - 以大写字母'T'或小写字母't'开头
[a-z]+ - 后面跟着一个或多个小写字母
m - 以字母'm'结尾

检查字符串 "hello tom,hello T3m,team" 中的各部分：

"tom" ：以't'开头，中间有小写字母'o'，以'm'结尾，符合模式
"T3m" ：虽然以'T'开头，以'm'结尾，但中间是数字'3'而不是小写字母，不符合模式
"team" ：以't'开头，中间有小写字母'e'和'a'，以'm'结尾，符合模式

11. (单选题)

var s2="tel:13955411234,TEL:16545457899,QQ:4646846"

var p2="1[(3-5)|(7-9)][0-9]{9}".r()

p2.findAllIn(s2).foreach(println(_))

输出结果是（）

A.tel:13955411234

B.tel:13955411234

TEL:16545457899

C.13955411234

D.13955411234

16545457899

答案及解析：C

解释：

让我们分析这个正则表达式 1[(3-5)|(7-9)][0-9]{9}：

1 - 匹配第一位数字必须是1（中国手机号都以1开头）
[(3-5)|(7-9)] - 这是一个字符类，里面包含字符 (, 3, -, 5, ), |, (, 7, -, 9, )
- 注意：虽然这可能是想表达"3-5或7-9范围的数字"，但实际上这个语法在正则表达式中不是这样工作的
- 第二位数字必须是这些字符之一，数字6不在其中
[0-9]{9} - 后面必须跟着9个数字

检查字符串中的电话号码：

"13955411234" ：以1开头，第二位是3（在允许的字符集中），后跟9位数字，符合模式
"16545457899" ：以1开头，但第二位是6（不在允许的字符集中），所以不符合模式
"4646846" ：不是以1开头，不符合模式

此外，findAllIn()方法只返回匹配的部分，而不包括前缀如"tel:"或"TEL:"。