Spark实战能力测评模拟题精析【上机考】

1.关于SparkStreaming说法正确的是（）

1应用场合为企业全数据处理；2应用场合为企业增量数据处理；3必须在下一块增量数据到达前，处理完当前增量数据；
A.1,2,3
B.2,3
C.1,3
D.1

2.println(List(1,2,3,4,5).reduce(_*_))

输出结果是
A.120
B.15
C.1 3 6 10 15
D.1 2 6 24 120

3.SparkStreaming是

A.实时流处理，产生结果无延时
B.离散流处理，产生结果无延时
C.离散流处理，产生结果有延时
D.实时流处理，产生结果有延时

4.val conf=new SparkConf（）
.setAppName("stream")
.setMaster("
conf.set("spark.testing.memory","2147480000")
val stream1=new StreamingContext(conf,Seconds（）)

为了创建一个片段为5000毫秒离散数据流，请填空
A.local[5] 5000
B.local 5
C.local[4] 5
D.local[2] 5000

5.与hadoop相比，Spark主要有以下哪些优点（）

1.提供多种数据集操作类型而不仅限于MapReduce
2.数据集中式计算而更加高效
3.提供了内存计算，带来了更高的迭代运算效率
4.基于DAG的任务调度执行机制
A.1,2,3,4
B.1,2
C.3,4
D.1,3,4

6.//1~100中有多少个2
var count:Int=0
for(n<-1 to 100){
__________
}
printin(count)
A.if（n%10==2)
    count++
if(n/10==2)
    count=++
B.if（n%10==2‖n/10==2)
    count=count+1
C.if（n%10==2 && n/10==2)
    count=count+1
D.if（n%10==2)
    count=count+1

if（n/10==2)
    count=count+1

7.

var pi=3.14
val circles=
(r*r*pi)
println(circles(10))
/实现求圆面积的闭包
A.(r:Double)=>
B.(r:Double)->
C.(r:Double)<-
D.(r:Double)=

8.println(List("k1"->99,"k2"->89).sortBy（）)

输出结果为List((k2,89),(k1,99)），请填空
A._._1
B._2
C.x=>x.1
D.y=>y._2

9.var str1="3室2厅|90.5平米|高层(共34层)|张三"，

var arr=str1.split("____")
println("经纪人："+arr（____）
println("户型："+arr（____）
A.,
B.I
C.\|
D.\\|

二、阅读理解

10.使用spark-core分析salarys.csv文件，各列含义如下：

岗位，城市，最低，最高，学历，工作经验

var sc=new SparkContext(conf)

var rdd1=sc.textFile("d:/salarys.cs"5510

var rdd2=rdd1.map(x=>x.split(","))

完成下面小题。

(1)（单选题）求出各个城市提供的岗位数

A.println(rdd2.map(x=>(x(1),1)).groupByKey（）.count（）)

B.rdd2.map(x=>(x(1),1)).reduceByKey(_+_).foreach(println)

C.println(rdd2.map(x=>(x(2),1)).groupByKey（）.count（）)

D.println(rdd2.map(x=>(x(1),1)).groupBy(_._2).count（）)

正确答案: B

分析：

• 我们需要统计每个城市的岗位数量，城市信息存储在数组的第2个元素(索引为1)
• map(x => (x(1), 1)) 将数据转换为 (城市, 1) 的键值对
• reduceByKey(_ + _) 按城市聚合并将值相加，得到每个城市的岗位总数
• foreach(println) 打印结果

其他选项问题：

• A：groupByKey() 后应该进行计算，而不是直接 count()，而且 count() 返回的是 RDD 中元素的总数，而非每个键的计数
• C：使用了错误的索引 x(2)，这是薪资最低值而非城市
• D：groupBy(_._2) 是按值 1 分组，这无法得到城市的岗位数

(2)（单选题）求各城市提供岗位的薪资最低值的平均值

A.rdd2.map(x=>(x(1),x(2).toDouble)).reduceByKey(_+_).foreach(println)

B.rdd2.map(x=>(x(0),x(2).toDouble)).reduceByKey().map(x=>(x._1,X._2.sum/x._2.size)).foreach(println)

C.rdd2.map(x=>(x(1),x(2).toDouble)).groupByKey().map(x=>(x._1,x._2.sum/x._2.size)).foreach(println)

D.rdd2.map(x=>(x(1),x(2))).groupByKey（）.map(x=>(x._1,x._2.sum/x._2.size)).foreach(println)

正确答案: C

分析：

• 需要计算每个城市的最低薪资平均值
• map(x => (x(1), x(2).toDouble)) 创建 (城市, 最低薪资) 键值对
• groupByKey() 按城市分组，得到 (城市, Iterable[薪资])
• map(x => (x._1, x._2.sum / x._2.size)) 计算每个城市的最低薪资平均值
• foreach(println) 打印结果

其他选项问题：

• A：只是求和，没有计算平均值
• B：reduceByKey() 缺少参数，语法错误
• D：没有将字符串转换为 Double，会导致类型错误

(3)求出最高工资的岗位及工资数额Top5

A.rdd2.map(x=>(x(2),x(3).toDouble)).sortBy(_.2,false).take(5).foreach(println)

B.rdd2.map(x=>(x(0),x(3)).sortBy(_._2).take(5).foreach(println)

C.rdd2.map(x=>(x(0),x(3).toDouble)).sortBy(_._2).take(5).foreach(println)

D.rdd2.map(x=>(x(0),x(3).toDouble)).sortBy(_._2,false).take(5).foreach(println)

正确答案: D

分析：

• 需要找出最高工资前5的岗位
• map(x => (x(0), x(3).toDouble)) 创建 (岗位, 最高薪资) 键值对
• sortBy(_._2, false) 按薪资降序排序（false 表示降序）
• take(5) 获取前5个结果
• foreach(println) 打印结果

其他选项问题：

• A：错误的索引 x(2) 是最低薪资而非岗位名称
• B：缺少括号，语法错误，且没有设置降序排序
• C：默认是升序排序，会返回最低的5个而非最高的

(4)用rdd3记录每个岗位的学历要求，与薪资均值（(min+max)/2

A.var rdd3=rdd2.map(x=>(x(4),(x(2).toDouble+x(3).toDouble)*0.5))

B.var rdd3=rdd2.map(x=>(x(4),(x(2)+x(3))/2))

C.var rdd3=rdd2.flatMap(x=>(x(4),(x(2).toDouble+x(3).toDouble)/2))

D.var rdd3=rdd2.map(x=>(x(4),(x(2).toDouble+x(3).toDouble)*0.5)).reduce(_+_)

正确答案: A

分析：

• 需要创建 (学历要求, 薪资均值) 的 RDD
• x(4) 是学历要求
• (x(2).toDouble + x(3).toDouble) * 0.5 计算最低和最高薪资的平均值
• 注意：*0.5 和 /2 在数学上是等价的

其他选项问题：

• B：没有将字符串转换为 Double，会导致字符串拼接而非数值计算
• C：flatMap 用法错误，应该返回集合而不是元组
• D：额外执行了 reduce(_+_)，会将所有记录合并为一个结果

(5)筛选出要求：工作经验1-3年的岗位

A.rdd2.map(x=>(x(0),x(5))).map(_,("1-3年")).foreach(println)

B.rdd2.map(x=>(x(0),x(5))).filter(_._2.equals("1-3年")).foreach(println)

C.rdd2.map(x=>(x(0),x(5))).groupByKey("1-3年").foreach(println)

D.rdd2.map(x=>(x(0),x(5))).filter(_.2>1 &_._2<3)).foreach(println)

正确答案: B

分析：

• 需要筛选工作经验为"1-3年"的岗位
• map(x => (x(0), x(5))) 创建 (岗位, 工作经验) 键值对
• filter(_._2.equals("1-3年")) 筛选工作经验为"1-3年"的记录
• foreach(println) 打印结果

其他选项问题：

• A：语法错误，map(_,("1-3年")) 不是有效的 Scala 语法
• C：groupByKey 用法错误，它需要一个键而不是过滤条件
• D：语法错误，且试图将字符串作为数字进行比较

(6)找出所有与数据有关的岗位及城市。

A.rdd2.map(x=>(x(0),x(1))).map(x=>(x(0),("数据"))).foreach(println)

B.rdd2.map(x=>(x(0),x(1))).filter(_._1.startswith("数据")).foreach(println)

C.rdd2.map(x=>(x(0),x(1))).filter(_._1.contains("数据")).foreach(println)

D.rdd2.map(x=>(x(0),x(1))).filter(_.contains("数据")).foreach(println)

正确答案: C

分析：

• 需要找出岗位名称中包含"数据"的记录
• map(x => (x(0), x(1))) 创建 (岗位, 城市) 键值对
• filter(_._1.contains("数据")) 筛选岗位名称包含"数据"的记录
• foreach(println) 打印结果

其他选项问题：

• A：语法错误，map(x => (x(0), (""))) 会丢失城市信息
• B：startswith 方法不存在，应该是 startsWith，且缺少搜索字符串
• D：语法错误，_.contains("") 无法访问元组的字段

11.读取学习通-资料-data-busdata.csv并数据分析

var rdd1=spark.read

        .option("header",true)

        .csv("d:/busdata.csv")

var df1=rdd1.toDF（）

df1.createOrReplaceTempView("bus")

var sql1="__"

var rs=spark.sql(sql1)

rs.show（）

(1)统计数据中有多少条公交线路？

A.select count(distinct bus_line)as n from bus

B.select count(distinct bus)as n from bus_line

C.select count(bus_line)as n from bus

D.select bus_line,count(*)as n from bus

正确答案：A

解析：

• A：使用count(distinct bus_line)统计不重复的公交线路数量 ✓
• B：语法错误，表名和字段名颠倒
• C：count(bus_line)会统计所有记录数，包含重复线路
• D：这是分组统计，不是统计线路总数

(2)统计现金、交通卡、移动支付各支付了多少单？

A.select payment_method,count(payment_method)as num_pay from bus order by payment_method

B.select payment_method,count(payment_method)as num_pay frombus group by bus_line

C.select payment_method,count(*)as num_pay from bus orderby by payment_method

D.select payment_method,count(*)as num_pay from bus group by payment_method

正确答案：D

解析：

• A：缺少group by子句，无法按支付方式分组
• B：按bus_line分组是错误的，应该按payment_method分组
• C：语法错误（order by by），且缺少group by
• D：正确使用group by payment_method进行分组统计 ✓

(3)（单选题）写出求各种支付方式消费金额排行榜的sql语句，并说明哪种支付方式消费金额最多？

A.select payment_method,sum(fare)as money from bus group by

payment_method order by money desc

B.支付金额最多的是：移动支付

select payment_method,sum(fare)as money from bus group by payment_method order by money desc

支付金额最多的是：交通卡

C.select payment_method,sum(fare)as money from bus group by

payment_method order by payment_method desc

支付金额最多的是：交通卡

D.select payment_method,sum(fare)as money from bus group by

payment_method order by payment_method desc

支付金额最多的是：移动支付

(4)统计出发站繁忙排行榜

A.var sql1="select boarding_stop,count(*)as boar_num from bus group by boarding_stop order by boar_num desc"

B.var sql1="select boarding_stop,count(boarding_stop)as boar_num from bus group by boarding_stop order by boarding_stop desc"

C.var sql1="select boarding_stop,sum(boarding_stop)as boar_num from bus group by boarding_stop order by boarding_stop desc"

D.var sql1="select boarding_stop,sum(boarding_stop)as boar_num from bus group by boarding_stop order by boarding_stop"

正确答案：A

解析：

• A：按出发站分组，统计次数，按次数降序排列 ✓
• B：按站点名称排序而非按繁忙程度排序
• C：使用sum(boarding_stop)语法错误，不能对字符串求和
• D：同C，且缺少desc

(5)所有订单统计乘车时间平均值。并展示结果

A.var sql1="select avg(unix_timestamp(to_timestamp(alighting_time,yyyy-MM-dd HH:mm))-unix_timestamp(to_timestamp(boarding_time,yyyy-MM-dd HH:mm')))/60 as avg_minute from bus

平均乘车时间：31分钟

B.var sql1="select

avg(unix_timestamp(to_timestamp(alighting_time,yyyy/MM/dd HH:mm))unix_timestamp(to_timestamp(boarding_time,yyyy/MM/dd HH:mm')))/60 as avg_minute from bus

平均乘车时间：31分钟○

C.var sql1="select avg(unix_timestamp(to_timestamp(alighting_time,'yyyy-MM-dd HH:mm))-unix_timestamp(to_timestamp(boarding_time,yyyy-MM-dd HH:mm'/60 as avg-.minute from bus”

平均乘车时间：29分钟

D.var sqll="select avg(unix_timestamp(to_timestamp(alighting_time,yyyy/MM/dd mmunix timestamp(to_timestamp(boarding time,yy-MM-dd HH:mm')))as avg_minute from bus

平均乘车时间：29分钟

正确答案：C