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

    s

  }

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

解释：

1. 并集操作 (set1 ++ set2):

   • 将两个集合的所有元素合并，去除重复元素
   • set1有元素 1,2,3
   • set2有元素 2,3,4
   • 合并后为 Set(1, 2, 3, 4)

2. 差集操作 (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表示：将门的状态取反(关变开，开变关)

完整代码应该是：

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

1. 带return关键字的完整形式

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

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

     2.无return的块表达式形式

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

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

     3.简化形式

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)

fp

答案及解析：A

解释：

1. 函数参数类型：

   • fp: (String=>String) 表示fp是一个函数类型参数
   • 这个函数接收一个String类型参数并返回一个String类型结果
   • 正好匹配了传入的(s:String)=>{"hello "+s}这个匿名函数

2. 函数体：

   • 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

解释：

1. 函数分析：

   • f1和f2都是接收一个String参数并返回String类型的函数
   • 例如：f1("tom") 会返回 "welcome tom"

2. 类型说明：

   • Array[String=>String] 表示"字符串到字符串函数"的数组类型
   • 这正好符合Array(f1, f2)的类型，因为f1和f2都是String=>String

3. 函数运行流程：

   • 外层循环遍历每个函数（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 的含义：

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

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

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

---

11. (单选题)

var s2="tel:[phone],TEL:[phone],QQ:4646846"

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

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

输出结果是（）

A.tel:[phone]

B.tel:[phone]

TEL:[phone]

C.13955411234

D.13955411234

16545457899

答案及解析：C

解释：

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

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

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

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

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