spark数据处理练习题番外篇【下】

12. (单选题)

spark-sql的优点（）

1 统一数据访问；2 包括具有行业标准JDBC和ODBC连接；3 对于交互式查询和长查询使用相同的引擎；4 

经过Catalyst优化后的sparkSQL执行效率高于RDD；

• A. 1，2，3，4
• B. 1，2
• C. 3，4
• D. 2，3，4

正确答案:A:1，2，3，4;

让我们分析一下每个选项：

Spark SQL的主要优点包括：

1. 统一数据访问 - √ 这是Spark SQL的重要优点，它提供了统一的方式来访问不同的数据源。

2. 包括具有行业标准JDBC和ODBC连接 - √ 这确实是Spark SQL的优点，支持标准的数据库连接协议。

3. 对于交互式查询和长查询使用相同的引擎 - √ Spark SQL使用同一个执行引擎处理不同类型的查询。

4. 经过Catalyst优化后的sparkSQL执行效率高于RDD - √ 这是正确的，Catalyst优化器能够优化SQL查询，使其性能优于原生RDD操作。

综上所述，所有提到的特点都是Spark SQL的优点。

13. (单选题)

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

正确答案:C:local[4] 5;

• local[4] 表示在本地模式下运行Spark，使用4个工作线程
• 5 表示5秒的批处理间隔

问题要求创建一个"片段为5000毫秒的离散数据流"。在Spark Streaming中，批处理间隔是以秒为单位的，所以5000毫秒等于5秒。

对于Master设置，local[n]中的n表示并行度，通常建议设置为至少比数据接收器数量多1，以避免接收数据和处理数据之间的资源竞争。

所以，正确的设置应该是使用local[n]（n至少为2）作为Master，以及5作为批处理间隔（表示5秒，即5000毫秒）。

14. (单选题)

val stream1=new StreamingContext(conf,Seconds(10))

val data=stream1.socketTextStream( "localhost" ,11111)

val data2=data.window(Seconds(__________),Seconds(__________))

data2为每10秒分析统计最近30秒的数据，请填空

• A. 3000  1000
• B. 30 10
• C. 20 20
• D. 10 10

正确答案:B:30 10;

让我分析这个问题：

首先理解问题要求：

• 每10秒分析一次数据（这是由stream1设置的批处理间隔决定的）
• 需要分析最近30秒的数据（这是窗口大小）
• 使用window函数，需要设置windowDuration和slideDuration

window函数的两个参数：

• 第一个参数是窗口长度(windowDuration)
• 第二个参数是滑动间隔(slideDuration)

具体分析：

• 要分析最近30秒的数据，所以windowDuration应该是30秒
• 每10秒分析一次，所以slideDuration应该是10秒
• 参数单位是秒（因为使用的是Seconds类）

检查选项：

• A: 3000, 1000 （这是毫秒值，而且太大）
• B: 30, 10 （这个符合要求：30秒窗口，10秒滑动）
• C: 20, 20 （不符合要求）
• D: 10, 10 （不符合要求）

15. (单选题)SparkStreaming是

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

正确答案:C:离散流处理，产生结果有延时;

让我解析为什么C是正确答案：

C是正确答案的原因：

离散流处理：

• Spark Streaming采用"微批处理"模式
• 将实时数据流分割成小的时间片段（批次）
• 每个批次作为一个RDD进行处理
• 本质上是将流处理转换为一系列小规模的批处理

产生结果有延时：

• 由于采用微批处理模式，需要等待每个批次数据收集完成
• 处理过程需要时间
• 批次间隔（如每5秒一个批次）本身就会导致延迟
• 结果产生会有固定的延迟时间

为什么其他选项错误：

A错误：

• 不是实时处理，而是离散批处理
• 不可能无延时，必然存在处理延迟

B错误：

• 虽然是离散流处理正确
• 但说无延时是错误的

D错误：

• 不是实时流处理，而是离散流处理
• 虽然有延时是对的，但第一个条件错误

因此，Spark Streaming的本质特征是离散流处理（微批处理），且因为处理模式的特点必然存在延时，

16. (单选题)

关于SparkStreaming说法正确的是（）

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

• A. 1，2 ，3
• B. 2 ， 3
• C. 1 ，3
• D. 1

正确答案:B:2 ， 3;

分析原因：

"应用场合为企业增量数据处理" - 正确

• SparkStreaming主要用于处理实时产生的增量数据
• 适合处理持续不断产生的数据流
• 常见场景如：日志分析、实时监控、用户行为分析等

"必须在下一块增量数据到达前，处理完当前增量数据" - 正确

• 这是SparkStreaming的基本工作原理
• 如果当前批次未处理完，会影响下一批次的处理
• 避免数据积压和处理延迟

"应用场合为企业全数据处理" - 错误

• SparkStreaming不适合处理全量数据
• 全量数据处理应该使用Spark Core或SparkSQL
• SparkStreaming专注于流式数据处理

所以：

• 选项B（2，3）是正确的
• 包含选项1的A、C、D都是错误的
• SparkStreaming的核心特点是增量数据处理而非全量数据处理

17. (单选题)

spark-sql读取多行json文件，请填空()

var df1=spark.read

      .option("multiline",________)

      .________("f:/worker.json")

      .toDF()

• A.

  false

  textFile

• B.

  true

  json

• C.

  header

  textFile

• D.

  header=true

  json

正确答案:B:true json;

问题要求使用spark-sql读取多行json文件，需要填写两个空白处。

分析各选项：

A. false, textFile

• "multiline"选项设为false表示每行是单独的JSON对象
• textFile方法读取的是纯文本文件，不会解析JSON结构

B. true, json

• "multiline"选项设为true表示允许一个JSON对象跨多行
• json方法专门用于读取和解析JSON格式文件

C. header, textFile

• "header"选项用于CSV文件，不适用于JSON
• textFile方法不会解析JSON结构

D. header=true, json

• "header=true"是CSV文件的选项，不适用于JSON
• 格式也不对，应该是.option("header", "true")

正确答案是 B. true, json

因为：

1. 多行JSON文件需要设置multiline=true，否则会解析错误
2. 读取JSON文件应该使用json()方法，而不是textFile()
3. 这样Spark才能正确解析跨多行的JSON对象

18. (单选题)

对score视图中3列（Java,c,python）完成求平均分，数据列别名设为pjf,并展示name和pjf的sql语句

select _________________ from __________

• A.

  (java+c+python)/3

  score

• B.

  name,(java+c+python)/3 as pjf

  scoreview

• C.

  name,(java+c+python)/3 as pjf

  score

• D.

  name,(java+c+python)/3 as pjf

  view

正确答案:C:name,(java+c+python)/3 as pjf score ;

让我分析这个SQL填空题：

题目要求：

1. 从score视图中选择数据
2. 计算Java、C和Python三列的平均分
3. 将平均分列命名为"pjf"
4. 同时显示name列和平均分列

分析各选项：

A. (java+c+python)/3 和 score

• 只选择了平均分，没有包含name列
• 没有给平均分设置别名pjf
• 表名可能正确，但缺少了视图的完整名称

B. name,(java+c+python)/3 as pjf 和 scoreview

• 选择了name列和平均分，并正确设置了别名pjf
• 但表名是scoreview，题目说的是score视图

C. name,(java+c+python)/3 as pjf 和 score

• 选择了name列和平均分，并正确设置了别名pjf
• 表名是score，与题目描述一致

D. name,(java+c+python)/3 as pjf 和 view

• 选择了name列和平均分，并正确设置了别名pjf
• 但表名是view，这不是一个有效的表名

19. (单选题)

数据前三行如下：

name,course,score

tom,java,90

mike,java,80

tom,c,70

求每门课及选课人数的spark-sql语句是（）

select ______________ from view1 ___________ course

• A.

  course,count(course)

  group by

• B.

  course,count(course)

  order by

• C.

  course,count(name)

  group by

• D.

  course,sum(course)

  groupbykey

正确答案:A:course,count(course) group by;

让我分析这个SQL查询题：

数据特点：

1. 包含name（学生姓名）、course（课程）和score（分数）三列
2. 同一个学生可能选多门课
3. 需要统计每门课的选课人数

分析各选项：

A. course,count(course) group by course

• 使用count(course)会统计课程名称的出现次数，这是正确的
• group by course正确地按课程分组
• 这是可行的方案

B. course,count(course) order by course

• order by只是排序，不能实现分组统计
• 不能得到每门课的选课人数

C. course,count(name) group by course

• count(name)统计每组中学生名字的出现次数
• group by course正确地按课程分组
• 这是最准确的答案

D. course,sum(course) groupbykey

• sum(course)不适合统计人数
• groupbykey不是SQL语法，是RDD操作
• 完全错误的语法

20. (单选题)

数据前4行如下：
name,course,score
tom,java,90
mike,java,80
jerry,c,60
tom,c,70

使用spark-core读取数据并map为科目与分数(整数类型)的元组集合（）

var line=sc.textFile("f:/datas/scores.txt")

• A. var rdd1=line.map(_.split(",")).map(x=>(x(0),x(2).toInt))
• B. var rdd1=line.map(_.split(",")).map(x=>(x(0),x(1),x(2)))
• C. var rdd1=line.map(_.split(",")).map(x=>(x(1),x(2).toInt))
• D. var rdd1=line.map(_.split(",")).map(x=>(x(0),x(1),x(2).toInt))

正确答案:C:var rdd1=line.map(_.split(",")).map(x=>(x(1),x(2).toInt));

让我分析这道题：

题目要求：

1. 使用spark-core读取数据
2. 需要将数据转换为(科目, 分数)的元组
3. 分数需要转换为整数类型
4. 科目在原数据中是第2列(course)，分数是第3列(score)

分析各选项：

A. map(x=>(x(0),x(2).toInt))

• 取第1列(name)和第3列(score)
• 不符合要求，应该取course而不是name

B. map(x=>(x(0),x(1),x(2)))

• 生成三元组，包含所有列
• 没有将分数转换为整数类型
• 不符合要求

C. map(x=>(x(1),x(2).toInt))

• 取第2列(course)和第3列(score)
• 将分数转换为整数类型
• 完全符合要求

D. map(x=>(x(0),x(1),x(2).toInt))

• 生成三元组，包含所有列
• 虽然将分数转换为整数，但返回三元组不符合要求

正确答案是 C：var rdd1=line.map(_.split(",")).map(x=>(x(1),x(2).toInt))

原因：

1. map(_.split(","))将每行文本分割成数组
2. map(x=>(x(1),x(2).toInt))创建(科目,分数)的二元组
3. x(1)获取科目(course)
4. x(2).toInt将分数转换为整数类型
5. 最终得到的是符合要求的(科目,分数)元组RDD

21. (单选题)

数据前4行如下：
name,course,score
tom,java,90
mike,java,80
jerry,c,60
tom,c,70
使用spark-core读取数据,筛选tom的数据，并map为name与分数(整数类型)的元组集合（）
var line=sc.textFile("f:/datas/scores.txt")
var rdd1=line.map(_.split(",")).map(x=>(x(0),x(1),x(2).toInt))

• A. rdd1.filter(_._1=="tom").map(x=>(x._1,x._3))
• B. rdd1.filter(_._1=="tom").map((_._1,_._2))
• C. rdd1.select(_._1=="tom").map(x=>(x._1,x._3))
• D. rdd1.select(name=="tom").map(x=>(x._2,x._3))

正确答案:A:rdd1.filter(_._1=="tom").map(x=>(x._1,x._3));

让我分析这道题：

题目要求：

1. 从已有的三元组RDD(name,course,score)中筛选tom的数据
2. 将结果转换为(name,score)的二元组
3. score需要保持整数类型

分析各选项：

A. rdd1.filter(_._1=="tom").map(x=>(x._1,x._3))

• filter(_._1=="tom")正确筛选name为tom的数据
• map(x=>(x._1,x._3))正确提取name和score
• 完全符合要求

B. rdd1.filter(_.1=="tom").map((.1,._2))

• filter正确
• 但map取了name和course，而不是name和score
• 不符合要求

C. rdd1.select(_._1=="tom").map(x=>(x._1,x._3))

• select不是RDD的方法，应该用filter
• 这是DataFrame的方法
• 语法错误

D. rdd1.select(name=="tom").map(x=>(x._2,x._3))

• select方法错误
• name=="tom"语法错误
• 结果取的是(course,score)而不是(name,score)
• 完全错误

正确答案是 A：rdd1.filter(_._1=="tom").map(x=>(x._1,x._3))

原因：

1. filter(_._1=="tom")正确使用了filter方法筛选tom的数据
2. _._1表示三元组的第一个元素(name)
3. map(x=>(x._1,x._3))正确提取了name(x._1)和score(x._3)
4. 保持了score的整数类型
5. 最终得到符合要求的(name,score)二元组RDD

22. (单选题)

关于数据倾斜说法正确的是（）

• A. HASH分区造成数据倾斜最严重
• B. 范围分区可以缓解数据倾斜
• C. 自定义分区一定比范围分区的数据倾斜小
• D. 自定义分区不会造成数据倾斜

正确答案:B:范围分区可以缓解数据倾斜;

让我分析关于数据倾斜的各个选项：

A. HASH分区造成数据倾斜最严重

• 这个说法不准确。Hash分区在数据分布均匀的情况下可以实现较好的负载均衡
• 但当数据中存在大量相同键值或hash函数不合理时，确实会导致数据倾斜
• 然而，不能说它"最严重"，因为其他分区方式在某些情况下可能更糟

B. 范围分区可以缓解数据倾斜

• 这个说法是正确的
• 范围分区(Range Partitioning)可以根据数据分布特点划分数据范围
• 通过合理设置范围边界，可以使各分区数据量更加均衡
• 特别是当我们预先了解数据分布时，范围分区能有效缓解数据倾斜问题

C. 自定义分区一定比范围分区的数据倾斜小

• 这个说法不正确
• 自定义分区的效果完全取决于分区逻辑的设计
• 设计不合理的自定义分区可能比范围分区造成更严重的数据倾斜
• 不能一概而论地说自定义分区一定更好

D. 自定义分区不会造成数据倾斜

• 这个说法不正确
• 自定义分区如果设计不当，同样会导致数据倾斜
• 没有任何分区策略能够绝对保证不会出现数据倾斜

正确答案是 B：范围分区可以缓解数据倾斜

原因：

1. 范围分区通过对数据进行排序并按照指定的范围边界划分，可以使各分区数据量更加均衡
2. 当我们了解数据分布特点时，可以合理设置范围边界，有针对性地解决数据倾斜问题
3. 其他选项都包含绝对化的错误说法，而B选项的表述是准确的

数据倾斜是分布式计算中的常见问题，没有万能的解决方案，需要根据具体数据特点选择合适的分区策略。

23. (单选题)

某rdd的key值如下：（1，5，9，14，26，79，86，92，99）

HASH分区分3个区，每个区的key是（）

• A.

  1，79

  5，14，26，86，92

  9，99

• B.

  1，5，9

  14，26，86，92

  99

• C.

  1，5，9，14

  26，79，86

  92，99

• D.

  5，9，14

  26，79，86

  92，99，1

正确答案:A:1，79  5，14，26，86，92 9，99;

让我分析这道关于Hash分区的题目：

题目要求：

• 有一个RDD，其key值为：1，5，9，14，26，79，86，92，99
• 使用Hash分区将数据分成3个区
• 需要确定每个区包含哪些key

分析： 在Spark中，Hash分区的计算方式是：key.hashCode() % numPartitions 对于整数key，hashCode()就是数字本身，所以计算公式简化为：key % numPartitions

让我计算每个key的分区：

• 1 % 3 = 1（第1区）
• 5 % 3 = 2（第2区）
• 9 % 3 = 0（第0区）
• 14 % 3 = 2（第2区）
• 26 % 3 = 2（第2区）
• 79 % 3 = 1（第1区）
• 86 % 3 = 2（第2区）
• 92 % 3 = 2（第2区）
• 99 % 3 = 0（第0区）

按分区整理：

• 第0区：9，99
• 第1区：1，79
• 第2区：5，14，26，86，92

对照选项： A.

• 第0区：9，99
• 第1区：1，79
• 第2区：5，14，26，86，92 这与我们的计算结果完全一致。

B、C、D选项都与计算结果不符。

正确答案是 A：

• 第0区：9，99
• 第1区：1，79
• 第2区：5，14，26，86，92

注意：在Spark中，分区编号是从0开始的，所以实际上是第0区、第1区和第2区，但题目中可能简化为第1区、第2区和第3区的表述方式。无论如何，A选项的分组是正确的。