奥鹏作业网《大数据开发技术（上）》课程期末复习资料
《大数据开发技术（上）》课程讲稿章节目录：
第1章 Spark概述
（1）了解Spark的发展及特点
（2）了解Spark的生态圈
（3）了解Spark的应用场景
第2章 Scala基础
（1）了解Scala简介及安装
（2）掌握Scala基础（1）
（3）掌握Scala基础（2）
（4）掌握Scala基础（3）
（5）掌握Scala数据结构（1）
（6）掌握Scala数据结构（2）
（7）掌握Scala类
第3章 Spark编程
（1）掌握创建RDD
（2）掌握RDD操作（1）
（3）掌握RDD操作（2）
（4）掌握RDD操作（3）
（5）掌握RDD操作（4）
（6）掌握文件的读取与存储
第4章 Spark编程进阶
（1）了解安装IDEA
（2）了解IDEA配置Spark运行环境
（3）掌握持久化
（4）掌握数据分区
（5）掌握练习——计算价格波动幅度
第5章 Spark SQL：结构化数据文件处理
（1）了解Spark SQL概述
（2）掌握DStream编程模型（1）
（3）掌握DStream编程模型（2）
（4）掌握练习——实时更新热门博文
第6章 Spark Streaming：实时计算框架
（1）了解Spark Streaming概述
（2）掌握DStream编程模型（1）
（3）掌握DStream编程模型（2）
（4）掌握练习——实时更新热门博文
第7章 Spark GraphX：图计算框架
（1）了解Spark GraphX概述
（2）掌握GraphX常用API（1）
（3）掌握GraphX常用API（2）
（4）掌握GraphX常用API（3）
（5）掌握GraphX常用API（4）
（6）掌握GraphX常用API（5）
（7）掌握MapReduce编程实践
第8章 Spark MLlib：功能强大的算法库
（1）了解MLlib算法库简介
（2）掌握Mllib算法与算法包（1）
（3）掌握Mllib算法与算法包（2）
（4）掌握Mllib算法与算法包（3）
（5）掌握Mllib算法与算法包（4）
（6）掌握练习——以Logistic实现用户分类（1）
（7）掌握练习——以Logistic实现用户分类（2）
第9章 项目案例：餐饮平台菜品智能推荐
（1）掌握项目案例——餐饮平台菜品智能推荐（1）
（2）掌握项目案例——餐饮平台菜品智能推荐（2）
（3）掌握项目案例——餐饮平台菜品智能推荐（3）
（4）掌握项目案例——餐饮平台菜品智能推荐（4）
（5）掌握项目案例——餐饮平台菜品智能推荐（5）
（6）了解可视化工具实践（3）
一、客观部分：（单项选择、多项选择、不定项选择、判断）
（一）、判断部分
1、Spark取代Hadoop仅仅是取代MapReduce这种计算框架，Spark可以取代HDFS吗
答案: 错
★难度：中
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
2、Spark是Apache基金会的顶级项目
答案: 对
★难度：易
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
3、Spark在同一个应用中不能同时使用Spark SQL和Mllib
答案: 错
★难度：中
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
4、用户可以在Hadoop YARN上运行Spark
答案: 对
★难度：易
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
5、用户可以在Apache Mesos上运行Spark
答案: 对
★难度：易
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
6、Spark SQL仅仅包括基本的SQL语法
答案: 错
★难度：难
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
7、Spark SQL包括基本的SQL语法和HiveQL语法
答案: 对
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
8、Scala是一种纯面向对象的语言，每个值都是对象。
答案: 对
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
9、Scala是Scalable Language的简写，是一门多范式的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。
答案: 对
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
10、Scala是Scalable Language的简写，是一门多范式的编程语言，设计初衷是不包括面向对象编程的特性。
答案: 错
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
11、Scala是Scalable Language的简写，是一门多范式的编程语言，设计初衷是不包括函数式编程的特性。
答案: 错
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
12、Scala其函数不能当成值来使用
答案: 错
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
13、Scala 配备了一种表现型的系统，它以静态的方式进行抽象，以安全和连贯的方式进行使用。
答案: 对
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
14、Scala 配备了一种表现型的系统，它以动态的方式进行抽象，以安全和连贯的方式进行使用。
答案: 错
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
15、Scala是不可扩展的
答案: 错
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
16、Scala中创建一个方法时经常用void表示该方法无返回值
答案: 错
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
17、Scala中用Unit表示无值，等同于Java中的void
答案: 对
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
18、Scala可以通过“var” 来定义变量，通过“val” 关键字来定义常量
答案: 对
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
19、Scala可以通过“val” 来定义变量，通过“var” 关键字来定义常量
答案: 错
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
20、val如同Java里面的非final变量，可以在它的声明周期中被多次赋值。
答案: 错
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
21、Scala中数组的第一个元素索引为1
答案: 错
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
22、Scala 语言中提供的数组是用来存储动态大小的同类型元素
答案: 错
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
23、Scala调用匿名函数可以将函数赋值给一个常量或变量，然后通过常量名或变量名调用该函数
答案: 对
★难度：易
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
24、Scala中高阶函数可以使用函数作为参数，也可以使用函数作为输出结果。
答案: 对
★难度：易
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
25、Scala中高阶函数经常将只需要执行多次的函数定义为匿名函数作为参数
答案: 错
★难度：中
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
26、Scala中高阶函数可以产生新的函数，并将新的函数作为返回值。
答案: 对
★难度：易
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
27、Scala中++i和i++表示变量i自增1
答案: 错
★难度：易
参见章节：第2章 第4节
考核知识点：Scala基础（3）
试题解析：
28、Scala 列表与数组非常相似，列表的所有元素可具有不同的类型。
答案: 错
★难度：易
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
29、Scala中列表是可变的
答案: 错
★难度：易
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
30、Scala列表中last返回列表最后一个元素
答案: 对
★难度：中
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
31、Scala列表中last返回一个列表，包含除了第一个元素之外的其他元素
答案: 错
★难度：中
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
32、Scala Set(集合)是没有重复的对象集合，所有的元素都是唯一的
答案: 对
★难度：易
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
33、Scala 集合分为可变的和不可变的集合
答案: 对
★难度：易
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
34、默认情况下，Scala 使用的是可变集合
答案: 错
★难度：易
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
35、Scala中集合连接时如果元素有重复的就会移除重复的元素
答案: 对
★难度：易
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
36、Scala中元组是是一种可迭代的键值对（key/value）结构。
答案: 错
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
37、Scala中默认情况下使用的是可变的Map
答案: 错
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
38、Scala中Map的isEmpty函数在Map为空时返回true
答案: 对
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
39、Scala中Map的isEmpty函数在Map为空时返回false
答案: 错
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
40、Scala中Map 合并时会移除重复的 key
答案: 对
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
41、Scala中元组可以包含不同类型的元素
答案: 对
★难度：中
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
42、Scala函数组合器可以通过一个函数重新计算列表中所有元素，没有返回值
答案: 错
★难度：中
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
43、Scala函数组合器中foreach和map类似，有返回值
答案: 错
★难度：中
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
44、Scala函数组合器中filter过滤移除使得传入的函数的返回值为true的元素
答案: 错
★难度：中
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
45、Scala函数组合器中flatten可以把嵌套的结构展开
答案: 对
★难度：中
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
46、Scala函数组合器中flatmap结合了map和flatten的功能，接收一个可以处理嵌套列表的函数，然后把返回结果连接起来
答案: 对
★难度：中
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
47、Scala函数组合器中groupBy是对集合中的元素进行分组操作，结果得到的是一个Map
答案: 对
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
48、Scala中允许集成多个父类
答案: 错
★难度：中
参见章节：第2章 第7节
考核知识点：Scala类
试题解析：
49、Scala在子类中重写超类的抽象方法时，需要使用override关键字
答案: 错
★难度：难
参见章节：第2章 第7节
考核知识点：Scala类
试题解析：
50、RDD是一个可读写的数据结构
答案: 错
★难度：易
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
51、SparkContext类中parallelize方法可将单机数据创建为分布式RDD
答案: 对
★难度：易
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
52、SparkContext类中makeRDD方法不可将单机数据创建为分布式RDD
答案: 错
★难度：易
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
53、RDD的转换操作通过某种函数将一个RDD 转换为一个新的RDD ， 但是转换操作是懒操作，不会立刻执行计算。
答案: 对
★难度：易
参见章节：第3章 第2节
考核知识点：RDD操作（1）
试题解析：
54、RDD的行动操作是用于触发转换操作的操作，这个时候才会真正开始进行计算。
答案: 对
★难度：易
参见章节：第3章 第2节
考核知识点：RDD操作（1）
试题解析：
55、RDD的行动操作通过某种函数将一个RDD 转换为一个新的RDD ， 但是转换操作是懒操作，不会立刻执行计算。
答案: 错
★难度：易
参见章节：第3章 第2节
考核知识点：RDD操作（1）
试题解析：
56、RDD的转换操作是用于触发转换操作的操作，这个时候才会真正开始进行计算。
答案: 错
★难度：易
参见章节：第3章 第2节
考核知识点：RDD操作（1）
试题解析：
57、RDD的map操作不会改变RDD的分区数目
答案: 对
★难度：易
参见章节：第3章 第2节
考核知识点：RDD操作（1）
试题解析：
58、RDD的flatMap操作是将函数应用于RDD 之中的每一个元素，将返回的迭代器(数组、列表等)中的所有元素构成新的RDD 。
答案: 对
★难度：易
参见章节：第3章 第2节
考核知识点：RDD操作（1）
试题解析：
59、RDD的mapPartitions操作会导致Partitions数量的变化
答案: 错
★难度：易
参见章节：第3章 第2节
考核知识点：RDD操作（1）
试题解析：
60、RDD的sortBy排序默认是升序
答案: 对
★难度：易
参见章节：第3章 第2节
考核知识点：RDD操作（1）
试题解析：
61、RDD的sortBy函数包含参数numPartitions，该参数决定排序后的RDD的分区个数，默认排序后的分区个数和排序之前的个数相等，即为this.partitions.size。
答案: 对
★难度：易
参见章节：第3章 第2节
考核知识点：RDD操作（1）
试题解析：
62、RDD的filter过滤会将返回值为true的过滤掉
答案: 错
★难度：易
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
63、RDD的filter函数返回一个存储符合过滤条件的所有元素的新RDD
答案: 对
★难度：易
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
64、RDD的union函数会将两个RDD元素合并成一个并且去处重复元素
答案: 错
★难度：难
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
65、RDD的subtract用于用于将前一个RDD 中在后一个RDD 出现的元素删除
答案: 对
★难度：难
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
66、RDD的subtract用于用于将后一个RDD 中在前一个RDD 出现的元素删除
答案: 错
★难度：难
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
67、RDD的intersection方法用于求出两个RDD 的共同元素
答案: 对
★难度：易
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
68、RDD的cartesian函数是笛卡尔积，也就是将两个集合的元素两两组合成一组
答案: 对
★难度：易
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
69、键值对RDD由一组组的键值对组成，这些RDD被称为PairRDD。
答案: 对
★难度：易
参见章节：第3章 第4节
考核知识点：RDD操作（3）
试题解析：
70、PairRDD中mapValues是针对键值对（Key，Value）类型的数据中的key和Value进行Map操作
答案: 错
★难度：易
参见章节：第3章 第4节
考核知识点：RDD操作（3）
试题解析：
71、PairRDD中groupBy（func）func返回key，传入的RDD的各个元素根据这个key进行分组。
答案: 对
★难度：易
参见章节：第3章 第4节
考核知识点：RDD操作（3）
试题解析：
72、PairRDD中groupByKey是对具有相同键的值进行分组
答案: 对
★难度：易
参见章节：第3章 第4节
考核知识点：RDD操作（3）
试题解析：
73、PairRDD中reduceByKey的功能是合并具有相同键的值，作用域是KeyValue 类型的键值对，并且是只对每个Key 的Value 进行处理
答案: 对
★难度：易
参见章节：第3章 第4节
考核知识点：RDD操作（3）
试题解析：
74、RDD中join操作最后只返回两个RDD 都存在的键的连接结果。
答案: 对
★难度：易
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
75、RDD中join操作根据键对两个RDD进行内连接，将两个RDD 中键相同的数据的值相加。
答案: 错
★难度：易
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
76、RDD中zip操作要求两个RDD的partition数量以及元素数量都相同
答案: 对
★难度：易
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
77、RDD中combineByKey不允许返回类型与输入数据类型不同的返回值
答案: 错
★难度：易
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
78、RDD中的collect 函数是一个行动操作，把RDD 所有元素转换成数组并返回到Driver 端，适用于大数据处理后的返回。
答案: 错
★难度：易
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
79、Spark RDD 是惰性求值的， 如果需要对一个RDD 多次使用，那么调用行动操作时每次都需要重复计算RDD 以及它的依赖。
答案: 对
★难度：中
参见章节：第4章 第3节
考核知识点：持久化
试题解析：
80、Spark持久化RDD 后，在再一次需要计算该RDD 时将需要重新计算
答案: 错
★难度：中
参见章节：第4章 第3节
考核知识点：持久化
试题解析：
81、如果其中有一个节点因为某种原因出现故障时， Spark 需要用到缓存数据时不会重算丢失的分区，因此不需要计算所有的分区。
答案: 错
★难度：易
参见章节：第4章 第3节
考核知识点：持久化
试题解析：
82、Spark对只有未曾设置存储级别的RDD才能设置存储级别，设置了存储级别的RDD不能修改其存储级别
答案: 对
★难度：易
参见章节：第4章 第3节
考核知识点：持久化
试题解析：
83、Spark只有键值对类型的RDD才能设置分区方式
答案: 对
★难度：易
参见章节：第4章 第4节
考核知识点：数据分区
试题解析：
84、Spark系统是根据一个针对键的函数对元素进行分区的，虽然不能控制每个键具体划分到哪个节点，但是可以控制相同的键落在同一个分区
答案: 对
★难度：易
参见章节：第4章 第4节
考核知识点：数据分区
试题解析：
85、Spark SQL可被视为一个分布式的SQL查询引擎，并且提供了一个叫做DataFrame的可编程抽象数据模型
答案: 对
★难度：易
参见章节：第5章 第1节
考核知识点：Spark SQL概述
试题解析：
86、DataFrame是一个分布式的Row对象的数据集合
答案: 对
★难度：易
参见章节：第5章 第1节
考核知识点：Spark SQL概述
试题解析：
87、Spark可以通过反射机制推断RDD模式
答案: 对
★难度：易
参见章节：第5章 第2节
考核知识点：DataFrame基础操作（1）
试题解析：
88、Spark的DataFrame只有在提交Action 操作时才会进行计算
答案: 对
★难度：易
参见章节：第5章 第2节
考核知识点：DataFrame基础操作（1）
试题解析：
89、Spark中DataFrame 的查询操作也是一个懒操作， 仅仅生成一个查询计划， 只有触发Action 操作才会进行计算并返回查询结果。
答案: 对
★难度：易
参见章节：第5章 第3节
考核知识点：DataFrame基础操作（2）
试题解析：
90、Spark Streaming中时间片也可称为批处理时间间隔(batch interval)，时间片是人为地对数据进行定量的标准，作为拆分数据的依据，一个时间片的数据对应一个RDD 实例。
答案: 对
★难度：易
参见章节：第6章 第1节
考核知识点：Spark Streaming概述
试题解析：
91、Spark Streming中Dstream是一种抽象的离散流
答案: 对
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
92、Spark Streming中DStream可以通过外部数据源（Kafka，Flume，Twitter等）来获取，也可以通过现有DStream的高级操作（Transformation操作）获得
答案: 对
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
93、Spark Streming中DStream代表着一系列的持续的RDDs
答案: 对
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
94、Spark Streming中对DStream的任何操作都会转化成对底层RDDs的操作
答案: 对
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
95、Dstream输出操作中foreachRDD的正确用法是使用rdd.foreachPartition方法创建一个单独的连接对象，然后使用该连接对象输出所有RDD分区中的数据到外部系统
答案: 对
★难度：易
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
96、Dstream提供了sort方法
答案: 错
★难度：易
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
97、图是由一个有穷非空顶点集合和一个描述顶点之间多对多关系的边集合组成的数据结构。
答案:
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
98、图（Graph）是一种复杂的非线性结构
答案: 对
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
99、图的出度数是以当前顶点为起点的边的数量
答案: 对
★难度：易
参见章节：第7章 第3节
考核知识点：GraphX常用API（2）
试题解析：
100、Spark GraphX课通过mapVertices[VD2: ClassTag](map: (VertexId, VD) => VD2)实现对顶点属性经过变换生成新的图
答案: 对
★难度：易
参见章节：第7章 第4节
考核知识点：GraphX常用API（3）
试题解析：
101、Spark GraphX课通过mapEdges[ED2](map: Edge[ED] => ED2)实现对边属性经过变换生成新的图
答案: 对
★难度：易
参见章节：第7章 第4节
考核知识点：GraphX常用API（3）
试题解析：
102、Spark GraphX课通过mapTriplets[ED2: ClassTag](map: EdgeTriplet[VD, ED] => ED2)
实现对边属性经过变换生成新的图
答案: 对
★难度：易
参见章节：第7章 第4节
考核知识点：GraphX常用API（3）
试题解析：
103、MLlib由一些通用的学习算法和工具组成，包括分类、回归、聚类、协同过滤、降维等，同时还包括底层的优化原语和高层的管道API。
答案: 对
★难度：易
参见章节：第8章 第1节
考核知识点：MLlib算法库简介
试题解析：
104、mllib.feature中存在一些常见的特征转化方法，主要包括创建特征向量和标准化数据
答案: 对
★难度：易
参见章节：第8章 第2节
考核知识点：Mllib算法与算法包（1）
试题解析：
105、MLlib中Normalizer是一个转换器，它可以将多行向量输入转化为统一的形式。
答案: 对
★难度：易
参见章节：第8章 第3节
考核知识点：Mllib算法与算法包（2）
试题解析：
106、MLlib中StandardScaler处理的对象是每一列，也就是每一维特征，将特征标准化为单位标准差或是0均值，或是0均值单位标准差。
答案: 对
★难度：易
参见章节：第8章 第3节
考核知识点：Mllib算法与算法包（2）
试题解析：
107、聚类是一种无监督学习的方法，用于将高度相似的数据分到一类中
答案: 对
★难度：易
参见章节：第8章 第5节
考核知识点：Mllib算法与算法包（4）
试题解析：
（二）、选择部分
1、MapReudce不适合（）任务
A.大数据计算
B.迭代
C.交互式
D.离线分析
答案: B C
★难度：难
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
2、Spark是一个（）计算框架
A.快速
B.分布式
C.可扩展
D.容错
答案: A B C D
★难度：中
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
3、一般情况下，对于迭代次数较多的应用程序，Spark程序在内存中的运行速度是Hadoop MapReduce运行速度的（）多倍
A.2
B.10
C.100
D.1000
答案: C
★难度：易
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
4、Spark支持使用（）语言编写应用
A.Scala
B.Python
C.Java
D.R
答案: A B C D
★难度：易
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
5、Spark包含的高级工具有（）
A.Spark SQL
B.Mllib
C.GraphX
D.park Streaming
答案: A B C D
★难度：易
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
6、Spark可以从（）分布式文件系统中读取数据
A.HDFS
B.Hbase
C.Hive
D.Tachyon
答案: A B C D
★难度：中
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
7、（）是Spark的核心，提供底层框架及核心支持
A.Spark Core
B.Spark SQL
C.Spark Streaming
D.Mllib
答案: A
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
8、Spark中的RDD的说法正确的是（）
A.弹性分布式数据集
B.是Spark中最基本的数据抽象
C.代表一个可变的集合
D.代表的集合里面的元素可并行计算
答案: A B D
★难度：难
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
9、Spark Core包含的功能有（）
A.任务调度
B.内存管理
C.SQL查询
D.容错机制
答案: A B D
★难度：难
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
10、Spark中运行交互式SQL查询的大规模并行查询引擎是（）
A.Spark Core
B.Spark SQL
C.BlinkDB
D.Mllib
答案: C
★难度：中
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
11、Spark SQL读取的数据源支持（）
A.Hive表
B.Parquent文件
C.JSON数据
D.关系数据库
答案: A B C D
★难度：中
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
12、Spark Streaming支持实时流式数据，包括（）
A.Web服务器日志文件
B.社交网络数据
C.实时交易数据
D.类似Kafka的信息数据
答案: A B C D
★难度：难
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
13、MLBase包括（）
A.Mllib
B.MLI
C.SparkR
D.GraphX
答案: A B
★难度：中
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
14、Mllib实现了一些常见的机器学习算法和应用程序，包括（）
A.分类
B.聚类
C.降维
D.回归
答案: A B C D
★难度：中
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
15、（）是Spark的数据挖掘算法库
A.Spark Core
B.BlinkDB
C.GraphX
D.Mllib
答案: D
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
16、（）可以解决图计算问题
A.Spark Core
B.BlinkDB
C.GraphX
D.Mllib
答案: C
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
17、（）是AMPLab发布的一个R开发包，使得R摆脱单机运行的命运，可以作为Spark的Job运行在集群上
A.SparkR
B.BlinkDB
C.GraphX
D.Mllib
答案: A
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
18、Scala源代码被编译成（）字节码，所以它可以运行于JVM之上
A.Spark
B.Scala
C.Java
D.JDK
答案: C
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
19、Scala类通过子类化和基于灵活的混合类来进行扩展，作为##的一个可靠性解决方案
A.多态
B.虚函数
C.派生
D.多重继承
答案: D
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
20、Scala支持（）
A.匿名函数
B.高阶函数
C.函数嵌套
D.柯里化
答案: A B C D
★难度：中
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
21、Scala系统支持（）作为对象成员
A.通用类
B.内部类
C.抽象类
D.复合类
答案: A B C D
★难度：中
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
22、Scala支持（）
A.显式参数
B.隐式参数
C.转换
D.多态方法
答案: A B C D
★难度：难
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
23、以下哪个不是Scala的数据类型（）
A.Int
B.Short Int
C.Long
D.Any
答案: B
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
24、以下哪个不是Scala的数据类型（）
A.AnyRef
B.Anything
C.NULL
D.Nothing
答案: B
★难度：中
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
25、以下哪个是Scala的数据类型（）
A.Any
B.NULL
C.Nothing
D.AnyRef
答案: A B C D
★难度：难
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
26、Scala通过（）来定义变量
A.val
B.val
C.define
D.def
答案: A
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
27、Scala通过（）来定义常量
A.val
B.val
C.define
D.def
答案: B
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
28、Scala中合并两个数组的方法是（）
A.line
B.add
C.append
D.concat
答案: D
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
29、Scala中哪个函数可以创建区间数组（）
A.concat
B.ofDim
C.fill
D.range
答案: D
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
30、Scala中如果函数无返回值，则函数返回类型为（）
A.NULL
B.Void
C.Nothing
D.Unit
答案: D
★难度：难
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
31、Scala函数支持（）
A.递归函数
B.高阶函数
C.柯里化
D.匿名函数
答案: A B C D
★难度：中
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
32、Scala中如果函数中的每个参数在函数中最多只出现一次，则可以使用占位符（）代替参数。
A.井号
B.下划线
C.斜杠
D.逗号
答案: B
★难度：中
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
33、递归函数意味着函数可以调用它（）
A.其他函数
B.主函数
C.子函数
D.自身
答案: D
★难度：易
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
34、var a=10;
while(a<20){
a+=1;
}
共循环了（）次
A.9
B.10
C.11
D.12
答案: B
★难度：易
参见章节：第2章 第4节
考核知识点：Scala基础（3）
试题解析：
35、var a=10;
do{
a+=1;
}while(a<20)
共循环了（）次
A.9
B.10
C.11
D.12
答案: B
★难度：易
参见章节：第2章 第4节
考核知识点：Scala基础（3）
试题解析：
36、var a=10;
for(a<-1 to 20){
println(a);
}
共循环了（）次
A.10
B.11
C.20
D.19
答案: C
★难度：难
参见章节：第2章 第4节
考核知识点：Scala基础（3）
试题解析：
37、var a=10;
for(a<-1 until 20){
println(a);
}
共循环了（）次
A.10
B.11
C.20
D.19
答案: D
★难度：难
参见章节：第2章 第4节
考核知识点：Scala基础（3）
试题解析：
38、下列Scala代码应输出（）：
var a=0;
var b=0
var sum=0;
for(a<-1 until 3; b<-1 until 3) {
sum+=a+b;
}
println(sum);
A.36
B.35
C.11
D.12
答案: D
★难度：难
参见章节：第2章 第4节
考核知识点：Scala基础（3）
试题解析：
39、Scala列表中（）可以表示为一个空列表
A.Nill
B.Nil
C.List
D.None
答案: B
★难度：易
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
40、Scala中构造列表的两个基本单位是 （）
A.Nil
B.Nill
C.::
D.List
答案: A C
★难度：
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
41、Scala列表方法中丢弃前n个元素，并返回新列表的方法是（）
A.drop
B.head
C.filter
D.init
答案: A
★难度：易
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
42、Scala列表方法中输出符号指定条件的所有元素的方法是（）
A.drop
B.head
C.filter
D.init
答案: C
★难度：中
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
43、Scala列表方法中获取列表的第一个元素的方法是（）
A.drop
B.head
C.filter
D.init
答案: B
★难度：易
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
44、Scala列表方法中返回所有元素，除了最后一个的方法是（）
A.drop
B.head
C.filter
D.init
答案: D
★难度：中
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
45、Scala列表方法中将函数应用到列表的所有元素的方法是（）
A.filter
B.foreach
C.map
D.mkString
答案: B
★难度：中
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
46、Scala列表方法中通过给定的方法将所有元素重新计算的方法是（）
A.filter
B.foreach
C.map
D.mkString
答案: C
★难度：中
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
47、Scala列表方法中使用分隔符将列表所有元素作为字符串显示的方法是（）
A.filter
B.foreach
C.map
D.mkString
答案: D
★难度：中
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
48、Scala中（）方法返回一个列表，包含除了第一个元素之外的其他元素
A.head
B.init
C.tail
D.last
答案: C
★难度：难
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
49、Scala中（）方法返回一个列表，包含除了最后一个元素之外的其他元素
A.head
B.init
C.tail
D.last
答案: B
★难度：难
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
50、Scala中可以用（）方法来连接两个或多个列表
A.::
B.#:::
C.List.:::()
D.List.concat()
答案: B C D
★难度：难
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
51、Scala中使用（）方法来查看两个集合的交集元素
A.Set.concat
B.Set.&
C.Set.&&
D.Set.intersect
答案: B D
★难度：难
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
52、Scala中使用（） 方法来连接两个集合
A.append
B.++
C.concat
D.Set.++()
答案: B D
★难度：难
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
53、Scala中（）方法返回Map所有的key
A.key
B.keys
C.value
D.values
答案: B
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
54、Scala中（）方法返回Map所有的value
A.key
B.keys
C.value
D.values
答案: D
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
55、Scala元组的值是通过将单个的值包含在（）中构成的
A.小括号
B.中括号
C.大括号
D.尖括号
答案: A
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
56、Scala函数组合器可以通过一个函数重新计算列表中所有元素，并且返回一个相同数目元素的新列表的方法是（）
A.map
B.foreach
C.flatten
D.flatmap
答案: A
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
57、Scala函数组合器可以通过一个函数重新计算列表中所有元素，但是没有返回值的方法是（）
A.map
B.foreach
C.flatten
D.flatmap
答案: B
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
58、Scala函数组合器可以过滤移除使得传入的函数的返回值为false的元素的方法是（）
A.filter
B.flatten
C.grouby
D.flatmap
答案: A
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
59、Scala函数组合器可以接收一个可以处理嵌套列表的函数，然后把返回结果连接起来的方法是（）
A.map
B.foreach
C.flatten
D.flatmap
答案: D
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
60、Scala函数组合器可以把一个二维的列表展开成一个一维的列表的方法是（）
A.filter
B.flatten
C.grouby
D.flatmap
答案: B
★难度：中
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
61、Scala函数组合器可以对集合中的元素进行分组操作，结果得到的是一个Map的方法是（）
A.filter
B.flatten
C.grouby
D.flatmap
答案: C
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
62、Scala 使用 （） 关键字来继承一个类
A.extends
B.override
C.extend
D.overrides
答案: A
★难度：中
参见章节：第2章 第7节
考核知识点：Scala类
试题解析：
63、Scala中重写一个非抽象方法必须使用（）修饰符。
A.extends
B.override
C.extend
D.overrides
答案: B
★难度：中
参见章节：第2章 第7节
考核知识点：Scala类
试题解析：
64、Scala可以使用（）关键字实现单例模式
A.object
B.static
C.private
D.public
答案: A
★难度：中
参见章节：第2章 第7节
考核知识点：Scala类
试题解析：
65、RDD是一个（）的数据结构
A.可读写
B.只读的
C.容错的
D.可进行并行操作的
答案: B C D
★难度：难
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
66、以下哪个方法可以从集合中创建RDD（）
A.parallelize
B.makeRDD
C.textFile
D.loadFile
答案: A B
★难度：中
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
67、以下哪个方法可以从外部存储中创建RDD（）
A.parallelize
B.makeRDD
C.textFile
D.loadFile
答案: C
★难度：易
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
68、以下哪个方法可以创建RDD（）
A.parallelize
B.makeRDD
C.textFile
D.loadFile
答案: A B C
★难度：中
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
69、Spark可以通过哪些外部存储创建RDD（）
A.文本文件
B.目录
C.压缩文件
D.通配符匹配的文件
答案: A B C D
★难度：易
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
70、RDD的（）操作通常用来划分单词
A.filter
B.union
C.flatmap
D.mapPartitions
答案: C
★难度：中
参见章节：第3章 第2节
考核知识点：RDD操作（1）
试题解析：
71、以下哪个函数可以对RDD进行排序（）
A.sortBy
B.filter
C.distinct
D.intersection
答案: A
★难度：易
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
72、以下哪个函数可以对RDD进行过滤（）
A.sortBy
B.filter
C.distinct
D.intersection
答案: B
★难度：易
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
73、以下哪个函数可以对RDD进行去重（）
A.sortBy
B.filter
C.distinct
D.intersection
答案: C
★难度：易
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
74、以下哪个函数可以对两个RDD进行合并（）
A.union
B.substract
C.intersection
D.cartesian
答案: A
★难度：中
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
75、以下哪个函数可以求两个RDD差集 （）
A.union
B.substract
C.intersection
D.cartesian
答案: B
★难度：难
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
76、以下哪个函数可以求两个RDD交集 （）
A.union
B.substract
C.intersection
D.cartesian
答案: C
★难度：难
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
77、以下哪个函数可以求两个RDD的笛卡尔积（）
A.union
B.substract
C.intersection
D.cartesian
答案: D
★难度：中
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
78、PairRDD的（）方法，可以把两个RDD中键相同的元素组合在一起，合并为一个RDD。
A.join
B.union
C.substract
D.intersection
答案: A
★难度：难
参见章节：第3章 第4节
考核知识点：RDD操作（3）
试题解析：
79、当需要将一个普通的RDD转化为一个PairRDD时可以使用（）函数来进行操作
A.transfer
B.change
C.map
D.build
答案: C
★难度：中
参见章节：第3章 第4节
考核知识点：RDD操作（3）
试题解析：
80、PairRDD可以通过（）获得仅包含键的RDD
A.key
B.keys
C.value
D.values
答案: B
★难度：易
参见章节：第3章 第4节
考核知识点：RDD操作（3）
试题解析：
81、PairRDD可以通过（）获得仅包含值的RDD
A.key
B.keys
C.value
D.values
答案: D
★难度：易
参见章节：第3章 第4节
考核知识点：RDD操作（3）
试题解析：
82、PairRDD中（）函数可以合并具有相同键的值
A.mapValues
B.groupBy
C.groupByKey
D.reduceByKey
答案: A
★难度：易
参见章节：第3章 第4节
考核知识点：RDD操作（3）
试题解析：
83、PairRDD中（）函数可以对具有相同键的值进行分组
A.mapValues
B.groupBy
C.groupByKey
D.reduceByKey
答案: C
★难度：易
参见章节：第3章 第4节
考核知识点：RDD操作（3）
试题解析：
84、PairRDD中（）函数可以进行分组
A.mapValues
B.groupBy
C.groupByKey
D.reduceByKey
答案: B C
★难度：易
参见章节：第3章 第4节
考核知识点：RDD操作（3）
试题解析：
85、请问RDD的（）操作是根据键对两个RDD进行内连接
A.join
B.zip
C.combineByKey
D.collect
答案: A
★难度：中
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
86、请问RDD的（）操作是将两个RDD组合成Key/Value形式的RDD
A.join
B.zip
C.combineByKey
D.collect
答案: B
★难度：中
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
87、请问RDD的（）操作用于将相同键的数据聚合
A.join
B.zip
C.combineByKey
D.collect
答案: C
★难度：中
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
88、请问RDD的（）操作把RDD 所有元素转换成数组并返回到Driver 端
A.join
B.zip
C.combineByKey
D.collect
答案: D
★难度：中
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
89、请问RDD的（）操作作用于K-V类型的RDD上，返回指定K的所有V值
A.search
B.find
C.findByKey
D.lookup
答案: D
★难度：中
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
90、请问RDD的（）操作用来计算RDD中所有元素个数
A.count
B.num
C.length
D.number
答案: A
★难度：中
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
91、Spark支持的文件格式包括（）
A.文本文件
B.JSON
C.CSV
D.SequenceFile
答案: A B C D
★难度：易
参见章节：第3章 第6节
考核知识点：文件的读取与存储
试题解析：
92、spark-submit配置项中（）表示Driver程序使用的内存大小
A.–driver-memory MEM
B.–executor-memory MEM
C.–total-executor-cores NUM
D.–executor-coures NUM
答案: A
★难度：易
参见章节：第4章 第2节
考核知识点：IDEA配置Spark运行环境
试题解析：
93、spark-submit配置项中（）表示executor内存大小
A.–num-executors NUM
B.–executor-memory MEM
C.–total-executor-cores NUM
D.–executor-coures NUM
答案: B
★难度：易
参见章节：第4章 第2节
考核知识点：IDEA配置Spark运行环境
试题解析：
94、spark-submit配置项中（）表示executor使用的总核数
A.–num-executors NUM
B.–executor-memory MEM
C.–total-executor-cores NUM
D.–executor-coures NUM
答案: C
★难度：易
参见章节：第4章 第2节
考核知识点：IDEA配置Spark运行环境
试题解析：
95、spark-submit配置项中（）表示启动的executor数量
A.–num-executors NUM
B.–executor-memory MEM
C.–total-executor-cores NUM
D.–executor-coures NUM
答案: A
★难度：易
参见章节：第4章 第2节
考核知识点：IDEA配置Spark运行环境
试题解析：
96、spark-submit配置项中（）表示每个executor使用的内核数
A.–num-executors NUM
B.–executor-memory MEM
C.–total-executor-cores NUM
D.–executor-coures NUM
答案: D
★难度：易
参见章节：第4章 第2节
考核知识点：IDEA配置Spark运行环境
试题解析：
97、Spark中的每个RDD一般情况下是由（）个分区组成的
A.0
B.1
C.多
D.无数
答案: C
★难度：易
参见章节：第4章 第3节
考核知识点：持久化
试题解析：
98、Spark的RDD持久化操作有()方式
A.cache
B.presist
C.storage
D.long
答案: A B
★难度：中
参见章节：第4章 第3节
考核知识点：持久化
试题解析：
99、如果numPartitions是分区个数，那么Spark每个RDD的分区ID范围是（）
A.[0,numPartitions]
B.[0,numPartitions-1]
C.[1,numPartitions-1]
D.[1,numPartitions]
答案: B
★难度：中
参见章节：第4章 第4节
考核知识点：数据分区
试题解析：
100、以下哪种方法可以让Spark不自定义分区也能对任何类型RDD 简单重分区（）
A.resetpartition
B.repartiton
C.Partition
D.coalesce
答案: B D
★难度：难
参见章节：第4章 第4节
考核知识点：数据分区
试题解析：
101、Spark SQL可以处理（）
A.RDD
B.Parquet文件
C.JSON文件
D.Hive表
答案: A B C D
★难度：易
参见章节：第5章 第1节
考核知识点：Spark SQL概述
试题解析：
102、以下哪个方法可以实现Spark SQL对数据的查询（）
A.SqlContext
B.MySQLContext
C.HiveContext
D.context
答案: A C
★难度：中
参见章节：第5章 第1节
考核知识点：Spark SQL概述
试题解析：
103、Spark创建DataFrame对象方式有（）
A.结构化数据文件
B.外部数据库
C.RDD
D.Hive中的表
答案: A B C D
★难度：易
参见章节：第5章 第2节
考核知识点：DataFrame基础操作（1）
试题解析：
104、Spark SQL 可以通过（）方法加载json文件为DataFrame
A.format
B.json
C.get
D.read
答案: A B
★难度：易
参见章节：第5章 第2节
考核知识点：DataFrame基础操作（1）
试题解析：
105、Spark DataFrame中（）方法可以获取若干行数据
A.first
B.head
C.take
D.collect
答案: A B C D
★难度：易
参见章节：第5章 第2节
考核知识点：DataFrame基础操作（1）
试题解析：
106、Spark DataFrame中（）方法可以获取所有数据
A.collect
B.take
C.takeAsList
D.collectAsList
答案: A D
★难度：易
参见章节：第5章 第2节
考核知识点：DataFrame基础操作（1）
试题解析：
107、Spark DataFrame中（）方法可以返回一个Array对象
A.collect
B.take
C.takeAsList
D.collectAsList
答案: A B
★难度：易
参见章节：第5章 第2节
考核知识点：DataFrame基础操作（1）
试题解析：
108、Spark DataFrame中（）方法可以返回一个List
A.collect
B.take
C.takeAsList
D.collectAsList
答案: C D
★难度：易
参见章节：第5章 第2节
考核知识点：DataFrame基础操作（1）
试题解析：
109、Spark中DataFrame的（）方法是进行条件查询
A.where
B.join
C.limit
D.apply
答案: A
★难度：易
参见章节：第5章 第3节
考核知识点：DataFrame基础操作（2）
试题解析：
110、Spark中DataFrame的（）方法是进行查询前n行记录
A.where
B.join
C.limit
D.apply
答案: C
★难度：易
参见章节：第5章 第3节
考核知识点：DataFrame基础操作（2）
试题解析：
111、Spark中DataFrame的（）方法是进行连接查询
A.where
B.join
C.limit
D.apply
答案: B
★难度：易
参见章节：第5章 第3节
考核知识点：DataFrame基础操作（2）
试题解析：
112、Spark中DataFrame的（）方法是进行排序查询
A.order by
B.group by
C.select by
D.sort by
答案: A
★难度：易
参见章节：第5章 第3节
考核知识点：DataFrame基础操作（2）
试题解析：
113、Spark中DataFrame的（）方法是进行分组查询
A.order by
B.group by
C.select by
D.sort by
答案: B
★难度：易
参见章节：第5章 第3节
考核知识点：DataFrame基础操作（2）
试题解析：
114、Spark中DataFrame的（）方法是查询指定字段的数据信息
A.select
B.selectExpr
C.col
D.apply
答案: A B C D
★难度：难
参见章节：第5章 第3节
考核知识点：DataFrame基础操作（2）
试题解析：
115、Spark Streaming的特点有（）
A.单极性
B.可伸缩
C.高吞吐量
D.容错能力强
答案: B C D
★难度：中
参见章节：第6章 第1节
考核知识点：Spark Streaming概述
试题解析：
116、Spark Streaming能够和（）无缝集成
A.Hadoop
B.Spark SQL
C.Mllib
D.GraphX
答案: B C D
★难度：中
参见章节：第6章 第1节
考核知识点：Spark Streaming概述
试题解析：
117、Spark Streaming能够处理来自（）的数据
A.Kafka
B.Flume
C.Twitter
D.ZeroMQ
答案: A B C D
★难度：中
参见章节：第6章 第1节
考核知识点：Spark Streaming概述
试题解析：
118、Spark Streming中DStream的每个RDD都是由（）分割开来的数据集
A.分区
B.一小段时间
C.数据量
D.随机
答案: B
★难度：中
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
119、Spark Streming中（）函数可以对源DStream中的每一个元素应用func方法进行计算，如果func函数返回结果为true，则保留该元素，否则丢弃该元素，返回一个新的Dstream
A.map
B.flatMap
C.filter
D.union
答案: C
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
120、Spark Streming中（）函数可以对源DStream的每个元素通过函数func返回一个新的DStream
A.map
B.flatMap
C.filter
D.union
答案: A
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
121、Spark Streming中（）函数可以对源DStream的每个元素通过函数func被映射出0或者更多的输出元素
A.map
B.flatMap
C.filter
D.union
答案: B
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
122、Spark Streming中（）函数可以合并两个DStream，生成一个包含两个DStream中所有元素的新DStream对象
A.map
B.flatMap
C.filter
D.union
答案: D
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
123、Spark Streming中（）函数可以对统计DStream中每个RDD包含的元素的个数，得到一个新的DStream
A.count
B.union
C.length
D.reduce
答案: A
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
124、Spark Streming中（）函数可以使用func将源DStream中的每个元素进行聚合操作，返回一个内部所包含的RDD只有一个元素的新DStream
A.union
B.reduce
C.join
D.cogroup
答案: B
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
125、Spark Streming中（）函数当被调用的两个DStream分别含有(K, V) 和(K, W)键值对时,返回一个(K, Seq[V], Seq[W])类型的新的DStream。
A.union
B.reduce
C.join
D.cogroup
答案: C
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
126、Spark Streming中（）函数当被调用类型分别为（K，V）和（K，W）键值对的2个DStream 时，返回类型为（K，（V，W））键值对的一个新 DStream。
A.union
B.reduce
C.join
D.cogroup
答案: D
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
127、Spark Streming中（）函数可以通过对源DStream的每RDD应用RDD-to-RDD函数返回一个新的DStream，这可以用来在DStream做任意RDD操作。
A.transform
B.reduce
C.join
D.cogroup
答案: A
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
128、Dstream窗口操作中（）方法返回一个基于源DStream的窗口批次计算后得到新的DStream。
A.window
B.countByWindow
C.reduceByWindow
D.reduceByKeyAndWindow
答案: A
★难度：易
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
129、Dstream窗口操作中（）方法返回基于滑动窗口的DStream中的元素的数量
A.window
B.countByWindow
C.reduceByWindow
D.reduceByKeyAndWindow
答案: B
★难度：易
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
130、Dstream窗口操作中（）方法基于滑动窗口对源DStream中的元素进行聚合操作，得到一个新的Dstream
A.window
B.countByWindow
C.reduceByWindow
D.reduceByKeyAndWindow
答案: C
★难度：易
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
131、Dstream窗口操作中（）方法基于滑动窗口对（K，V）键值对类型的DStream中的值按K使用聚合函数func进行聚合操作，得到一个新的Dstream
A.window
B.countByWindow
C.reduceByWindow
D.reduceByKeyAndWindow
答案: D
★难度：易
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
132、Dstream输出操作中（）方法在Driver中打印出DStream中数据的前10个元素。
A.print
B.saveAsTextFiles
C.saveAsObjectFiles
D.saveAsHadoopFiles
答案: A
★难度：易
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
133、Dstream输出操作中（）方法将DStream中的内容以文本的形式保存为文本文件
A.print
B.saveAsTextFiles
C.saveAsObjectFiles
D.saveAsHadoopFiles
答案: B
★难度：易
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
134、Dstream输出操作中（）方法在Driver中打印出DStream中数据的前12个元素。
A.print
B.saveAsTextFiles
C.saveAsObjectFiles
D.saveAsHadoopFiles
答案: C
★难度：易
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
135、Dstream输出操作中（）方法将DStream中的内容按对象序列化并且以SequenceFile的格式保存
A.print
B.saveAsTextFiles
C.saveAsObjectFiles
D.saveAsHadoopFiles
答案: D
★难度：易
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
136、Dstream输出操作中print方法在Driver中打印出DStream中数据的()元素。
A.第一个
B.所有
C.前10个
D.前100个
答案: C
★难度：中
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
137、图的结构通常表示为：G(V,E)，其中，G表示（）
A.图
B.子图
C.顶点
D.边
答案: A
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
138、图的结构通常表示为：G(V,E)，其中，V是图G中()
A.顶点
B.顶点的集合
C.边
D.边的集合
答案: B
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
139、图的结构通常表示为：G(V,E)，其中，E是图G中()
A.顶点
B.顶点的集合
C.边
D.边的集合
答案: D
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
140、图是一种数据元素间为（）关系的数据结构
A.多对多
B.一对一
C.一对多
D.多对一
答案: A
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
141、在图结构中，每个元素都可以有（）前驱
A.至少一个
B.零个或多个
C.一个
D.零个
答案: B
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
142、在图结构中，每个元素都可以有（）后继
A.至少一个
B.零个或多个
C.一个
D.零个
答案: B
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
143、图结构中如果任意两个顶点之间都存在边，那么称之为（）
A.完全图
B.有向完全图
C.无向图
D.简单图
答案: A
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
144、图结构中如果任意两个顶点之间都存在有向边，那么称之为（）
A.完全图
B.有向完全图
C.无向图
D.简单图
答案: B
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
145、图结构中如果无重复的边或者顶点到自身的边，那么称之为（）
A.完全图
B.有向完全图
C.无向图
D.简单图
答案: D
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
146、GraphX中Edge边对象存有（）字段
A.srcId
B.dstId
C.attr
D.val
答案: A B C
★难度：中
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
147、GraphX中（）是存放着Edg对象的RDD
A.RDD[Edge]
B.EdgeRDD
C.RDD[(VertexId,VD)]
D.VertexRDD
答案: A
★难度：易
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
148、GraphX中（）是完整提供边的各种操作类
A.RDD[Edge]
B.EdgeRDD
C.RDD[(VertexId,VD)]
D.VertexRDD
答案: B
★难度：易
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
149、GraphX中（）是存放着存放顶点的RDD
A.RDD[Edge]
B.EdgeRDD
C.RDD[(VertexId,VD)]
D.VertexRDD
答案: C
★难度：易
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
150、GraphX中（）是提供顶点的各种操作方法的对象
A.RDD[Edge]
B.EdgeRDD
C.RDD[(VertexId,VD)]
D.VertexRDD
答案: D
★难度：易
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
151、GraphX中EdgeRDD继承自（）
A.EdgeRDD
B.RDD[Edge]
C.VertexRDD[VD]
D.RDD[(VertexId，VD)]
答案: B
★难度：易
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
152、GraphX中VertexRDD[VD]继承自（）
A.EdgeRDD
B.RDD[Edge]
C.VertexRDD[VD]
D.RDD[(VertexId，VD)]
答案: D
★难度：易
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
153、Graph类中如果要根据分开存放的顶点数据和边数据创建图，应该用（）方法
A.Graph(vertices,edges, defaultVertexAttr)
B.Graph.fromEdges(RDD[Edge[ED]], defaultValue)
C.Graph.fromEdgeTuples(rawEdges: RDD[(VertexId, VertexId)], defaultValue,)
D.GraphLoader.edgeListFile(sc,filename)
答案: A
★难度：中
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
154、Graph类中如果根据边数据创建图，数据需要转换成RDD[Edge[ED]类型，应该用（）方法
A.Graph(vertices,edges, defaultVertexAttr)
B.Graph.fromEdges(RDD[Edge[ED]], defaultValue)
C.Graph.fromEdgeTuples(rawEdges: RDD[(VertexId, VertexId)], defaultValue,)
D.GraphLoader.edgeListFile(sc,filename)
答案: B
★难度：中
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
155、Graph类中如果要根据边数据创建图，边数据需要加载为二元组，可以选择是否对边分区，应该用（）方法
A.Graph(vertices,edges, defaultVertexAttr)
B.Graph.fromEdges(RDD[Edge[ED]], defaultValue)
C.Graph.fromEdgeTuples(rawEdges: RDD[(VertexId, VertexId)], defaultValue,)
D.GraphLoader.edgeListFile(sc,filename)
答案: C
★难度：中
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
156、Graph类中如果要直接通过边数据文件创建图，要求数据按空格分隔，应该用（）方法
A.Graph(vertices,edges, defaultVertexAttr)
B.Graph.fromEdges(RDD[Edge[ED]], defaultValue)
C.Graph.fromEdgeTuples(rawEdges: RDD[(VertexId, VertexId)], defaultValue,)
D.GraphLoader.edgeListFile(sc,filename)
答案: D
★难度：中
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
157、GraphX中（）方法可以缓存整个图
A.cache
B.presist
C.unpersistVertices
D.edges.unpersist
答案: A B
★难度：中
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
158、GraphX中（）方法可以缓存整个图，并指定存储级别
A.cache
B.presist
C.unpersistVertices
D.edges.unpersist
答案: B
★难度：难
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
159、GraphX中（）方法可以释放顶点缓存
A.cache
B.presist
C.unpersistVertices
D.edges.unpersist
答案: C
★难度：中
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
160、GraphX中（）方法可以释放边缓存
A.cache
B.presist
C.unpersistVertices
D.edges.unpersist
答案: D
★难度：中
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
161、GraphX中（）方法可以查询顶点个数
A.numVertices
B.numEdges
C.vertices
D.edges
答案: A
★难度：易
参见章节：第7章 第3节
考核知识点：GraphX常用API（2）
试题解析：
162、GraphX中（）方法可以查询边数
A.numVertices
B.numEdges
C.vertices
D.edges
答案: B
★难度：易
参见章节：第7章 第3节
考核知识点：GraphX常用API（2）
试题解析：
163、GraphX中（）方法可以查询顶点信息
A.numVertices
B.numEdges
C.vertices
D.edges
答案: C
★难度：易
参见章节：第7章 第3节
考核知识点：GraphX常用API（2）
试题解析：
164、GraphX中（）方法可以查询边信息
A.numVertices
B.numEdges
C.vertices
D.edges
答案: D
★难度：易
参见章节：第7章 第3节
考核知识点：GraphX常用API（2）
试题解析：
165、GraphX中（）方法可以查询度数
A.degrees
B.degree
C.vertices
D.edges
答案: A
★难度：难
参见章节：第7章 第3节
考核知识点：GraphX常用API（2）
试题解析：
166、GraphX中graph.vertices可以得到（）
A.顶点视图
B.边视图
C.顶点与边的三元组整体视图
D.有向图
答案: A
★难度：易
参见章节：第7章 第3节
考核知识点：GraphX常用API（2）
试题解析：
167、GraphX中graph.edges可以得到（）
A.顶点视图
B.边视图
C.顶点与边的三元组整体视图
D.有向图
答案: B
★难度：易
参见章节：第7章 第3节
考核知识点：GraphX常用API（2）
试题解析：
168、GraphX中graph.triplets可以得到（）
A.顶点视图
B.边视图
C.顶点与边的三元组整体视图
D.有向图
答案: C
★难度：易
参见章节：第7章 第3节
考核知识点：GraphX常用API（2）
试题解析：
169、Spark GraphX中类Graph的reverse方法可以（）
A.反转图中所有边的方向
B.按照设定条件取出子图
C.取两个图的公共顶点和边作为新图，并保持前一个图顶点与边的属性
D.合并边相同的属性
答案: A
★难度：易
参见章节：第7章 第5节
考核知识点：GraphX常用API（4）
试题解析：
170、Spark GraphX中类Graph的subgraph方法可以（）
A.反转图中所有边的方向
B.按照设定条件取出子图
C.取两个图的公共顶点和边作为新图，并保持前一个图顶点与边的属性
D.合并边相同的属性
答案: B
★难度：易
参见章节：第7章 第5节
考核知识点：GraphX常用API（4）
试题解析：
171、Spark GraphX中类Graph的mask方法可以（）
A.反转图中所有边的方向
B.按照设定条件取出子图
C.取两个图的公共顶点和边作为新图，并保持前一个图顶点与边的属性
D.合并边相同的属性
答案: C
★难度：易
参见章节：第7章 第5节
考核知识点：GraphX常用API（4）
试题解析：
172、Spark GraphX中类Graph的groupEdges方法可以（）
A.反转图中所有边的方向
B.按照设定条件取出子图
C.取两个图的公共顶点和边作为新图，并保持前一个图顶点与边的属性
D.合并边相同的属性
答案: D
★难度：易
参见章节：第7章 第5节
考核知识点：GraphX常用API（4）
试题解析：
173、Spark GraphX中类Graph的collectNeighbors(edgeDirection: EdgeDirection)方法可以（）
A.收集邻居顶点的顶点Id和顶点属性
B.收集邻居顶点的顶点Id
C.向指定顶点发送信息并聚合信息
D.将顶点信息更新到图中
答案: A
★难度：易
参见章节：第7章 第6节
考核知识点：GraphX常用API（5）
试题解析：
174、Spark GraphX中类Graph的collectNeighborIds(edgeDirection: EdgeDirection)方法可以（）
A.收集邻居顶点的顶点Id和顶点属性
B.收集邻居顶点的顶点Id
C.向指定顶点发送信息并聚合信息
D.将顶点信息更新到图中
答案: B
★难度：易
参见章节：第7章 第6节
考核知识点：GraphX常用API（5）
试题解析：
175、Spark GraphX中类Graph的mapReduceTriplets方法可以（）
A.收集邻居顶点的顶点Id和顶点属性
B.收集邻居顶点的顶点Id
C.向指定顶点发送信息并聚合信息
D.将顶点信息更新到图中
答案: C
★难度：易
参见章节：第7章 第6节
考核知识点：GraphX常用API（5）
试题解析：
176、Spark GraphX中类Graph的aggregateMessages方法可以（）
A.收集邻居顶点的顶点Id和顶点属性
B.收集邻居顶点的顶点Id
C.向指定顶点发送信息并聚合信息
D.将顶点信息更新到图中
答案: C
★难度：易
参见章节：第7章 第6节
考核知识点：GraphX常用API（5）
试题解析：
177、Spark GraphX中类Graph的joinVertices方法可以（）
A.收集邻居顶点的顶点Id和顶点属性
B.收集邻居顶点的顶点Id
C.向指定顶点发送信息并聚合信息
D.将顶点信息更新到图中
答案: D
★难度：易
参见章节：第7章 第6节
考核知识点：GraphX常用API（5）
试题解析：
178、以下是机器学习的常用算法的是（）
A.回归算法
B.聚类算法
C.降维算法
D.分类算法
答案: A B C D
★难度：易
参见章节：第8章 第1节
考核知识点：MLlib算法库简介
试题解析：
179、以下算法中属于分类算法的是（）
A.KNN算法
B.逻辑回归
C.随机森林
D.Kmeans
答案: A B C
★难度：易
参见章节：第8章 第1节
考核知识点：MLlib算法库简介
试题解析：
180、以下算法中属于聚类算法的是（）
A.KNN算法
B.逻辑回归
C.随机森林
D.Kmeans
答案: D
★难度：易
参见章节：第8章 第1节
考核知识点：MLlib算法库简介
试题解析：
181、以下算法中属于监督学习算法的是（）
A.KNN算法
B.逻辑回归
C.随机森林
D.Kmeans
答案: A B C
★难度：中
参见章节：第8章 第1节
考核知识点：MLlib算法库简介
试题解析：
182、以下算法中属于无监督学习算法的是（）
A.KNN算法
B.逻辑回归
C.随机森林
D.Kmeans
答案: D
★难度：中
参见章节：第8章 第1节
考核知识点：MLlib算法库简介
试题解析：
183、TF-IDF中TF指的是（）
A.词频
B.词在文档中出现的次数
C.逆文档概率
D.词在文档集中出现的概率
E.词在文档集中出现的概率
答案: A B
★难度：易
参见章节：第8章 第2节
考核知识点：Mllib算法与算法包（1）
试题解析：
184、TF-IDF中IDF指的是（）
A.词频
B.词在文档中出现的次数
C.逆文档概率
D.词在文档集中出现的概率
E.词在文档集中出现的概率
答案: C D
★难度：易
参见章节：第8章 第2节
考核知识点：Mllib算法与算法包（1）
试题解析：
185、MLlib中进行数据标准化的方式有（）
A.Normalizer
B.Standard
C.StandardScaleer
D.MinMaxScaler
答案: A C D
★难度：中
参见章节：第8章 第3节
考核知识点：Mllib算法与算法包（2）
试题解析：
186、MLlib中用于线性回归算法的包主要有（）
A.LinearRegressionWithSGD
B.RidgeRegressionWithSGD
C.LassoWithSGD
D.LeftRegression
答案: A B C
★难度：中
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
187、Mllib中线性会馆算法中的参数numIterations表示（）
A.要运行的迭代次数
B.梯度下降的步长
C.是否给数据加干扰特征或者偏差特征
D.Lasso 和ridge 的正规化参数
答案: A
★难度：易
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
188、Mllib中线性会馆算法中的参数stepSize表示（）
A.要运行的迭代次数
B.梯度下降的步长
C.是否给数据加干扰特征或者偏差特征
D.Lasso 和ridge 的正规化参数
答案: B
★难度：易
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
189、Mllib中线性会馆算法中的参数intercept表示（）
A.要运行的迭代次数
B.梯度下降的步长
C.是否给数据加干扰特征或者偏差特征
D.Lasso 和ridge 的正规化参数
答案: C
★难度：易
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
190、Mllib中线性会馆算法中的参数reParam表示（）
A.要运行的迭代次数
B.梯度下降的步长
C.是否给数据加干扰特征或者偏差特征
D.Lasso 和ridge 的正规化参数
答案: D
★难度：易
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
191、在MLlib中，逻辑回归算法的输入值为（）类型
A.Double
B.LabledPoint
C.Point
D.SGB
答案: B
★难度：中
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
192、决策树是（）的常用算法
A.分类
B.聚类
C.降维
D.回归
答案: A D
★难度：中
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
193、MLlib 中可以调用mllib.tree.DecisionTree 类中的静态方法（）训练分类树
A.trainClassifier
B.trainRegressor
C.LogisticRegressionModel
D.LabeledPoint
答案: A
★难度：易
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
194、MLlib 中可以调用mllib.tree.DecisionTree 类中的静态方法（）训练回归树
A.trainClassifier
B.trainRegressor
C.LogisticRegressionModel
D.LabeledPoint
答案: B
★难度：易
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
195、Mllib中metrics.precisionByThreshold表示（）指标
A.准确度
B.召回率
C.F值
D.ROC曲线
答案: A
★难度：易
参见章节：第8章 第5节
考核知识点：Mllib算法与算法包（4）
试题解析：
196、Mllib中metrics.recallByThreshold
表示（）指标
A.准确度
B.召回率
C.F值
D.ROC曲线
答案: B
★难度：易
参见章节：第8章 第5节
考核知识点：Mllib算法与算法包（4）
试题解析：
197、Mllib中metrics.fMeasureByThreshold
表示（）指标
A.准确度
B.召回率
C.F值
D.ROC曲线
答案: C
★难度：易
参见章节：第8章 第5节
考核知识点：Mllib算法与算法包（4）
试题解析：
198、Mllib中metrics.roc
表示（）指标
A.准确度
B.召回率
C.F值
D.ROC曲线
答案: D
★难度：易
参见章节：第8章 第5节
考核知识点：Mllib算法与算法包（4）
试题解析：
二、主观部分：
（一）、填空部分
1、Spark中间输出结果可以保存在______中，减少读写HDFS的次数。
答案: 内存
★难度：易
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
2、______是Spark的核心，提供底层框架及核心支持
答案: Spark Core
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
3、______是Spark中最基本的数据抽象
答案: RDD或弹性分布式数据集
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
4、Scala 是一种纯粹的面向对象语言，其中一个对象的类型和行为是由______和特征来描述的。
答案: 类
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
5、Scala 是一种纯粹的面向对象语言，其中一个对象的类型和行为是由类和______来描述的。
答案: 特征
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
6、Scala交互式解释器的缩写是______
答案: REPL
★难度：易
参见章节：第2章 第1节
考核知识点：Scala简介及安装
试题解析：
7、val类似于Java里的______变量。一旦初始化了，val就不能再被赋值。
答案: final
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
8、Scala数组中某个指定的元素是通过______来访问的
答案: 索引
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
9、Scala中定义val arr：Array[String]=Array(“baidu”,”google”,”biying”)，那么arr.length返回值为______
答案: 3
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
10、Scala中定义val arr：Array[String]=Array(“baidu”,”google”,”biying”)，那么arr.head返回值为______
答案: baidu
★难度：中
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
11、Scala中定义val arr：Array[String]=Array(“baidu”,”google”,”biying”)，那么arr.tail返回值为______
答案: Array(“google”,”biying”)
★难度：难
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
12、Scala中定义val arr：Array[String]=Array(“baidu”,”google”,”biying”)，那么arr.isEmpty返回值为______
答案: 假
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
13、Scala中定义val arr：Array[String]=Array(“baidu”,”google”,”biying”)，那么arr.contains(“biying”)返回值为______
答案: 真
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
14、Scala中合并两个数组的方法是______
答案: concat
★难度：易
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
15、Scala中创建区间数组Array(1,3,5,7,9)，使用方法range(1,______,2)
答案: 10
★难度：中
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
16、Scala中创建区间数组Array(1,3,5,7,9)，使用方法range(______,10,2)
答案: 1
★难度：中
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
17、Scala中创建区间数组Array(1,3,5,7,9)，使用方法range(1,10,______)
答案: 2
★难度：中
参见章节：第2章 第2节
考核知识点：Scala基础（1）
试题解析：
18、Scala中定义函数的关键字是______
答案: def
★难度：易
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
19、Scala中既不带参数也不返回有用结果的函数定义为
def print():______={println(“Exam”)}
答案: Unit
★难度：难
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
20、当递归调用是函数的最后一个语句时，我们称之为______递归
答案: 尾
★难度：难
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
21、补充函数实现返回指定区间的值的和：
def add(a:Int,b:Int):Int={
if(a>b) 0
else ______
}
答案: a+add(a+1,b)
★难度：难
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
22、补充函数实现返回指定区间的值的和：
def add(f:Int=>Int, a:Int,b:Int):Int={
if(a>b) 0
else ______
}
答案: f(a)+addInt(f,a+1,b)
★难度：难
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
23、补充函数实现计算两个数的最大公因数：
def gcd(a:Int,b:Int):Int={
if(a==0) b
else ______
}
答案: gcd(b%a,a)
★难度：难
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
24、var a=10;
while(a<20){
a+=1;
}
共循环了______次
答案: 10
★难度：中
参见章节：第2章 第4节
考核知识点：Scala基础（3）
试题解析：
25、var a=10;
do{
a+=1;
}while(a<20)
共循环了______次
答案: 10
★难度：中
参见章节：第2章 第4节
考核知识点：Scala基础（3）
试题解析：
26、var a=10;
for(a<-1 to 20){
println(a);
}
共循环了______次
答案: 20
★难度：难
参见章节：第2章 第4节
考核知识点：Scala基础（3）
试题解析：
27、var a=10;
for(a<-1 until 20){
println(a);
}
共循环了______次
答案: 19
★难度：难
参见章节：第2章 第4节
考核知识点：Scala基础（3）
试题解析：
28、下列Scala代码应输出______：
var a=0;
var b=0
var sum=0;
for(a<-1 to 3; b<-1 to 4) {
sum+=a+b;
}
println(sum);
答案: 36
★难度：难
参见章节：第2章 第4节
考核知识点：Scala基础（3）
试题解析：
29、Scala列表方法中丢弃前n个元素，并返回新列表的方法是______
答案: drop
★难度：易
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
30、Scala列表方法中输出符号指定条件的所有元素的方法是______
答案: filter
★难度：中
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
31、Scala列表方法中获取列表的第一个元素的方法是______
答案: head
★难度：易
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
32、Scala列表方法中返回所有元素，除了最后一个的方法是______
答案: init
★难度：中
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
33、Scala列表方法中将函数应用到列表的所有元素的方法是______
答案: foreach
★难度：中
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
34、Scala列表方法中通过给定的方法将所有元素重新计算的方法是______
答案: map
★难度：中
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
35、Scala列表方法中使用分隔符将列表所有元素作为字符串显示的方法是______
答案: mkString
★难度：中
参见章节：第2章 第5节
考核知识点：Scala数据结构（1）
试题解析：
36、Scala函数组合器可以通过一个函数重新计算列表中所有元素，并且返回一个相同数目元素的新列表的方法是______
答案: map
★难度：中
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
37、Scala函数组合器可以通过一个函数重新计算列表中所有元素，但是没有返回值的方法是______
答案: foreach
★难度：中
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
38、Scala函数组合器可以过滤移除使得传入的函数的返回值为false的元素的方法是______
答案: filter
★难度：难
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
39、Scala函数组合器可以接收一个可以处理嵌套列表的函数，然后把返回结果连接起来的方法是______
答案: flatmap
★难度：难
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
40、Scala函数组合器可以把一个二维的列表展开成一个一维的列表的方法是______
答案: flatten
★难度：难
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
41、Scala函数组合器k可以对集合中的元素进行分组操作，结果得到的是一个Map的方法是______
答案: groupby
★难度：易
参见章节：第2章 第6节
考核知识点：Scala数据结构（2）
试题解析：
42、面向对象语言中类是对象的抽象，也可以把______理解为模板
答案: 类
★难度：易
参见章节：第2章 第7节
考核知识点：Scala类
试题解析：
43、面向对象语言中类是对象的抽象，______才是真正的实体。
答案: 对象
★难度：易
参见章节：第2章 第7节
考核知识点：Scala类
试题解析：
44、Spark中sc的全拼是______
答案: SparkContext
★难度：易
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
45、假设集合A 有5 个元素，集合B 有10 个元素，使用RDDcartesian函数会返回______个元素的组合
答案: 50
★难度：难
参见章节：第3章 第3节
考核知识点：RDD操作（2）
试题解析：
46、初始化SparkContext需要一个______对象
答案: SparkConf
★难度：易
参见章节：第4章 第2节
考核知识点：IDEA配置Spark运行环境
试题解析：
47、因为Spark有数据持久化特性，英雌如果希望节点故障不影响执行速度，在内存充足的情况下，可以使用______的高可靠机制
答案: 双副本保存
★难度：难
参见章节：第4章 第3节
考核知识点：持久化
试题解析：
48、Spark中每一个RDD都可以用不同的存储级别进行保存，从而允许持久化数据集在硬盘或者在内存作为序列化的______对象
答案: Java
★难度：难
参见章节：第4章 第3节
考核知识点：持久化
试题解析：
49、针对仅存储数据在内存中的存储策略，如果内存不足的话，Spark会使用______缓存策略清除最老的分区，为新的RDD提供空间
答案: LRU
★难度：难
参见章节：第4章 第3节
考核知识点：持久化
试题解析：
50、Spark中设置分区方式使用______函数
答案: partitionBy
★难度：中
参见章节：第4章 第4节
考核知识点：数据分区
试题解析：
51、Spark如果要实现自定义分区器，需要继承 org.apache.spark.______类
答案: Partitioner
★难度：中
参见章节：第4章 第4节
考核知识点：数据分区
试题解析：
52、Spark中的coalesce方法采用______分区方式
答案: HashPartitioner
★难度：难
参见章节：第4章 第4节
考核知识点：数据分区
试题解析：
53、Spark SQL 可以通过______方法将HDFS 上的格式化文件转换为DataFrame
答案: load
★难度：易
参见章节：第5章 第2节
考核知识点：DataFrame基础操作（1）
试题解析：
54、Spark中需将DataFrame注册成为______表，然后才能通过SQL语句进行查询
答案: 临时
★难度：中
参见章节：第5章 第3节
考核知识点：DataFrame基础操作（2）
试题解析：
55、Dstream输出操作中print方法在Driver中打印出DStream中数据的前______个元素。
答案: 10
★难度：中
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
56、GraphX中Edge类包含srcId必须是______类型
答案: Long
★难度：中
参见章节：第7章 第2节
考核知识点：GraphX常用API（1）
试题解析：
57、图中以当前顶点为目标点的边的数量是______度数
答案: 入
★难度：易
参见章节：第7章 第3节
考核知识点：GraphX常用API（2）
试题解析：
58、GraphX中三元视图逻辑上将顶点和边的属性保存为一个RDD[EdgeTriplet[VD,ED]]，它包含______类的实例
答案: EdgeTriplet
★难度：中
参见章节：第7章 第3节
考核知识点：GraphX常用API（2）
试题解析：
59、Spark GraphX中类Graph的______方法可以反转图中所有边的方向
答案: reverse
★难度：难
参见章节：第7章 第5节
考核知识点：GraphX常用API（4）
试题解析：
60、Spark GraphX中类Graph的______方法可以按照设定条件取出子图
答案: subgraph
★难度：难
参见章节：第7章 第5节
考核知识点：GraphX常用API（4）
试题解析：
61、Spark GraphX中类Graph的______方法可以取两个图的公共顶点和边作为新图，并保持前一个图顶点与边的属性
答案: mask
★难度：难
参见章节：第7章 第5节
考核知识点：GraphX常用API（4）
试题解析：
62、Spark GraphX中类Graph的______方法可以合并边相同的属性
答案: groupEdges
★难度：难
参见章节：第7章 第5节
考核知识点：GraphX常用API（4）
试题解析：
63、Spark GraphX中类Graph的______方法可以收集邻居顶点的顶点Id和顶点属性
答案: collectNeighbors
★难度：难
参见章节：第7章 第6节
考核知识点：GraphX常用API（5）
试题解析：
64、Spark GraphX中类Graph的______方法可以收集邻居顶点的顶点Id
答案: collectNeighborIds
★难度：难
参见章节：第7章 第6节
考核知识点：GraphX常用API（5）
试题解析：
65、Spark GraphX中类Graph的______方法可以向指定顶点发送信息并聚合信息
答案: mapReduceTriplets
或者aggregateMessages
★难度：难
参见章节：第7章 第6节
考核知识点：GraphX常用API（5）
试题解析：
66、Spark GraphX中类Graph的______方法可以将顶点信息更新到图中
答案: joinVertices或者outerJoinVertices
★难度：难
参见章节：第7章 第6节
考核知识点：GraphX常用API（5）
试题解析：
67、Mllib中基本数据类型：______表示数据向量，包括稀疏向量和稠密向量
答案: Vector
★难度：中
参见章节：第8章 第2节
考核知识点：Mllib算法与算法包（1）
试题解析：
68、Mllib中基本数据类型：______表示监督式学习算法的数据对象，包含一个标签和一个特征向量
答案: LabeledPoint
★难度：中
参见章节：第8章 第2节
考核知识点：Mllib算法与算法包（1）
试题解析：
69、Mllib中基本数据类型：______表示对产品的评分，用于推荐ALS算法
答案: Rating
★难度：中
参见章节：第8章 第2节
考核知识点：Mllib算法与算法包（1）
试题解析：
70、Mllib中线性会馆算法中的参数numIterations默认值是______
答案: 100
★难度：难
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
71、Mllib中线性会馆算法中的参数stepSize默认值是______
答案: 1
★难度：难
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
72、Mllib中线性会馆算法中的参数intercept默认值是______
答案: 假
★难度：难
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
73、Mllib中线性会馆算法中的参数reParam默认值是______
答案: 1
★难度：难
参见章节：第8章 第4节
考核知识点：Mllib算法与算法包（3）
试题解析：
74、MLlib 中的KMeans算法的参数maxIterations默认值是______
答案: 100
★难度：易
参见章节：第8章 第5节
考核知识点：Mllib算法与算法包（4）
试题解析：
（二）、名词解释题
1、Spark
答案: 快速、分布式、可扩展、容错的集群计算框架
★难度：易
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
2、Spark Core
答案: Spark核心，提供底层框架及核心支持。包含Spark的基本功能，包括任务调度、内存管理、容错机制等。
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
3、BlinkDB
答案: 一个用于在海量数据上运行交互式SQL查询的大规模并行查询引擎
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
4、Mllib
答案: MLlib是Spark的数据挖掘算法库，实现了一些常见的机器学习算法和实用程序，包括分类、回归、聚类、协同过滤、降维以及底层优化。
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
5、SparkR
答案: SparkR是AMPLab发布的一个R开发包，使得R摆脱单机运行的命运，可以作为Spark的Job运行在集群上
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
6、REPL
答案: Scala交互式解释器REPL（Read-Evaluate-Print-Loop），它是编写Scala表达式和程序的交互式“shell”
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
7、尾递归
答案: 当递归调用是函数的最后一个语句时，称为尾递归
★难度：中
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
8、柯里化
答案: 指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程
★难度：中
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
9、匿名函数
答案: 匿名函数即是在定义函数的时候不给出函数名
★难度：易
参见章节：第2章 第3节
考核知识点：Scala基础（2）
试题解析：
10、Scala object
答案: Scala中使用单例模式时需要使用object定义一个单例对象（object对象），单例对象就是在整个程序中只有这么一个实例。
★难度：易
参见章节：第2章 第7节
考核知识点：Scala类
试题解析：
11、Scala样例类
答案: 在Scala中，使用了case关键字定义的类称为样例类，样例类是一种特殊的类，经过优化用于模式匹配。
★难度：中
参见章节：第2章 第7节
考核知识点：Scala类
试题解析：
12、RDD
答案: RDD是一个容错的、只读的、可进行并行操作的数据结构，是一个分布在集群各个节点的存放元素的集合。
★难度：易
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
13、JSON
答案: JSON 是一种使用较广的半结构化数据格式。
JSON 指的是JavaScript 对象表示法，是轻量级的文本数据交换格式。JSON 解析器和JSON 库支持许多不同的编程语言。
★难度：易
参见章节：第3章 第6节
考核知识点：文件的读取与存储
试题解析：
14、SequenceFile
答案: SequenceFile 是由没有相对关系结构的键值对文件组成的常用Hadoop 格式
★难度：易
参见章节：第3章 第6节
考核知识点：文件的读取与存储
试题解析：
15、SparkContext
答案: SparkContext是Spark应用程序的上下文和入口，无论是Scala、Python、R程序，都是通过SparkContext对象的实例来创建RDD，Spark Shell中的sc就是SparkContext对象的实例。
★难度：易
参见章节：第4章 第2节
考核知识点：IDEA配置Spark运行环境
试题解析：
16、Spark SQL
答案: Spark SQL 是一个用来处理结构化数据的Spark 组件
★难度：易
参见章节：第5章 第1节
考核知识点：Spark SQL概述
试题解析：
17、DataFrame
答案: DataFrame是Spark SQL提供的最核心的编程抽象
★难度：易
参见章节：第5章 第1节
考核知识点：Spark SQL概述
试题解析：
18、Spark Streaming
答案: Spark Streaming是Spark系统中用于处理流式数据的分布式流式处理框架
★难度：易
参见章节：第6章 第1节
考核知识点：Spark Streaming概述
试题解析：
19、DStream
答案: DStream 即离散流(discretized stream) ，是Spark Streaming 对内部持续的实时数据流的抽象描述
★难度：易
参见章节：第6章 第1节
考核知识点：Spark Streaming概述
试题解析：
20、Spark Streming中 Dstream
答案: Spark Streaming提供了一个高层次的抽象叫做离散流（discretized stream）或者DStream，代表了持续性的数据流。
★难度：易
参见章节：第6章 第2节
考核知识点：DStream编程模型（1）
试题解析：
21、Spark GraphX
答案: Spark GraphX是一个分布式图处理框架，是一个基于Spark平台提供图计算和图挖掘的简洁易用且丰富多彩的接口，极大地方便了大家对分布式图处理的需求。
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
22、Mllib
答案: MLlib是Spark的机器学习（ML）库，旨在简化机器学习的工程实践工作，并方便扩展到更大规模，同时利用Spark分布式处理来实现模型，处理大数据全量数据的迭代计算。
★难度：易
参见章节：第8章 第1节
考核知识点：MLlib算法库简介
试题解析：
23、TF-IDF
答案: 一种将文档转化成向量表示的方法。TF指的是词频，即该词在文档中出现的次数，IDF是逆文档概率，是词在文档集中出现的概率，它们的乘积表示该词在文档中的重要程度
★难度：易
参见章节：第8章 第2节
考核知识点：Mllib算法与算法包（1）
试题解析：
24、Word2Vec
答案: Word2Vec是NLP领域的重要算法，它的功能是将每个word用K维的稠密向量来表达，训练集是语料库，不含标点，以空格断句。
★难度：易
参见章节：第8章 第3节
考核知识点：Mllib算法与算法包（2）
试题解析：
（三）、问答题
1、为什么说Spark是Hadoop MapReduce的替代方案?
答案: 1. MapReudce不适合迭代和交互式任务，Spark主要为交互式查询和迭代算法设计，支持内存存储和高效的容错恢复。
2.Spark拥有MapReduce具有的优点，但不同于MapReduce，Spark中间输出结果可以保存在内存中，减少读写HDFS的次数。
★难度：易
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
2、Spark 与Hadoop MapReduce 的运行速度为何会有如此大的差异?
答案: 1.Spark多步计算，中间数据存放于内存中，有更高的迭代运算效率，
2.而Hadoop两步计算，每次迭代的中间数据存放于HDFS 中，涉及硬盘的读写，明显降低了运算效率。
★难度：中
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
3、请简述Spark的特点
答案: 1. 快速
2. 易用性
3. 通用性
4. 多种运行模式
5. 代码简洁
★难度：中
参见章节：第1章 第1节
考核知识点：Spark的发展及特点
试题解析：
4、Spark Streaming的基本原理
答案: 将Stream数据分成小的时间片段，以类似batch批量处理的方式来处理这小部分数据
★难度：中
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
5、Spark Streaming构建在Spark上的原因
答案: 一方面因为Spark的低延时执行引擎可以用于实时计算，另一方面相比基于Record的其他处理框架（如storm），RDD数据集更容易做高效的容错处理。
★难度：中
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
6、MLBase分为哪四部分
答案: MLlib、MLI、ML Optimizer和MLRuntime
★难度：易
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
7、图的并行化处理的重点是
答案: 1. 如何将图的算法并行化，
2. 找到一个合适的并行化处理框架
★难度：难
参见章节：第1章 第2节
考核知识点：Spark的生态圈
试题解析：
8、请解释伴生对象与伴生类
答案: 当单例对象与某个类共享同一个名称时，单例对象被称作是这个类的伴生对象，类被称为是这个单例对象的伴生类。
★难度：中
参见章节：第2章 第7节
考核知识点：Scala类
试题解析：
9、请简述RDD的创建方式
答案: RDD 有3 种不同的创建方法。一种是对程序中存在的基本数据结构中的集合进行并行化(如Set 、List、Array) ，另一种是通过已有RDD 转化得到新的RDD ，这两种都是通过内存已有集合创建RDD。还有一种是直接读取外部存储的数据集。
★难度：易
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
10、请简述如何从集合中创建RDD
答案: SparkContext 类中有两个方法: paralelize 和makeRDD 。通过parallelize 或makeRDD可将单机数据创建为分布式RDD 。这两种方法都是利用内存中已存在的集合，复制集合的元素去创建一个可用于并行计算的分布式数据集RDD 。
★难度：易
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
11、请简述如何从外部存储创建RDD
答案: 从外部读取数据创建RDD 可以有很多种数据来源，通过SparkContext 对象的textFile方法读取数据集，支持多种类型数据集，如目录、文本文件、压缩文件和通配符匹配的文件等，并且允许设定分区个数。
★难度：易
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
12、SparkContext类中parallelize方法的分区数参数如果不设置，默认值为什么？
答案: 不设分区数，则默认为该Application 分配到的资源的CPU 数
★难度：中
参见章节：第3章 第1节
考核知识点：创建RDD
试题解析：
13、请简述RDD的转换操作和行动操作的区别
答案: 转换操作和行动操作。转换操作通过某种函数将一个RDD 转换为一个新的RDD ， 但是转换操作是懒操作，不会立刻执行计算。行动操作是用于触发转换操作的操作，这个时候才会真正开始进行计算。
★难度：易
参见章节：第3章 第2节
考核知识点：RDD操作（1）
试题解析：
14、请论述RDD的sortBy函数的参数个数及功能
答案: sortBy()是对标准RDD 进行排序的方法，有3 个如下可输入参数。
（1）第一个参数是一个函数f: (T) => K ，左边是要被排序对象中的每一个元素，右边返回的值是元素中要进行排序的值。
（2）第二个参数是ascending ，决定排序后RDD 中的元素是升序还是降序，默认是true ，也就是升序，如果要降序则需要写人参数false
（3）第三个参数是numPartitions ，该参数决定排序后的RDD 的分区个数，默认排序后的分区个数和排序之前的个数相等，即为this.partitions
★难度：易
参见章节：第3章 第2节
考核知识点：RDD操作（1）
试题解析：
15、请说明RDD中combineByKey的参数
答案: createCombiner: V => C ，这个函数把当前的值作为参数，此时我们可以对其做些附加操作(类型转换)并把它返回 (这一步类似于初始化操作)
mergeValue: (C, V) => C，该函数把元素V合并到之前的元素C(createCombiner)上 (这个操作在每个分区内进行)
mergeCombiners: (C, C) => C，该函数把2个元素C合并 (这个操作在不同分区间进行)
★难度：中
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
16、请问RDD的collect函数为什么适用于小数据处理后的返回。
答案: 因为需要从集群各个节点收集数据到本地，经过网络传输，并且加载到Driver 内存中，如果数据量大的话，会给网络造成很大的压力。所以数据量比较大的时候，尽量不要使用collect 函数，因为这可能导致Driver 端内存溢出问题。
★难度：中
参见章节：第3章 第5节
考核知识点：RDD操作（4）
试题解析：
17、请对spark-submit参数进行解释
答案: 1.class：应用程序的入口点，指主程序。
2.master：指定要连接的集群URL。可以接收的值如表4‑3所示。
3.deploy-mode：是否将驱动程序部署在工作节点（cluster）或本地作为外部客户端（client）。
4.conf：设置任意Spark配置属性，即允许使用key=value格式设置任意的SparkConf配置选项。
5.application-jar：包含应用程序和所有依赖关系的捆绑JAR的路径。
6.application-arguments：传递给主类的main方法的参数。
★难度：中
参见章节：第4章 第2节
考核知识点：IDEA配置Spark运行环境
试题解析：
18、请对spark-submit的配置项中spark.cores.max进行描述
答案: 当应用程序运行在Standalone集群或者粗粒度共享模式Mesos集群时，应用程序向集群请求的最大CPU内核总数（不是指每台机器，而是整个集群）。如果不设置，对于Standalone集群将使用spark.deploy. defaultCores中的数
值，而Mesos将使用集群中可用的内核
★难度：难
参见章节：第4章 第2节
考核知识点：IDEA配置Spark运行环境
试题解析：
19、请问Spark为什么对数据进行持久化
答案: 由于Spark RDD 是惰性求值的， 如果需要对一个RDD 多次使用，那么调用行动操作时每次都需要重复计算RDD 以及它的依赖。在迭代算法计算中，由于常常需要对同一组数据多次使用，因此消耗会格外大。所以为了避免多次计算同一个RDD ， 可以让Spark 对数据进行持久化。
★难度：易
参见章节：第4章 第3节
考核知识点：持久化
试题解析：
20、请问Spark RDD数据分区的意义
答案: Spark RDD是多个分区组成的数据集合，在分布式程序中，通信的代价是很大的，因此控制数据分区、减少网络传输是提高整体性能的一个重要的方面。
★难度：中
参见章节：第4章 第4节
考核知识点：数据分区
试题解析：
21、请简述如何获取Spark的RDD分区方式
答案: 要获取RDD的分区方式，可以使用RDD 的partitioner 方法，该方法会返回一个scala.Option 对象，这是Scala 用来存放可能存在的对象的容器。可以通过这个Option 对象调用isDetined 来查看其中是否有值，用get 来获取其中的值，值是一个spark.Partitioner 对象。
★难度：中
参见章节：第4章 第4节
考核知识点：数据分区
试题解析：
22、请简述Spark系统的三种数据分区方式
答案: 一种是哈希分区( HashPartitioner )，根据哈希值分配
另一种是范围分区( RangePartitioner )，将一定范围的数据映射到一个分区中。
用户也可以通过自定义分区器来完成特定的分区要求。
★难度：中
参见章节：第4章 第4节
考核知识点：数据分区
试题解析：
23、Spark如果要实现自定义分区器，需要继承 org.apache.spark.Partitioner类并实现其中哪几个方法
答案: 1. def numPartitions:Int：这个方法返回想要创建的分区个数
2. def getPartition(key: Any)：这个函数需要对输入的 key做处理，然后返回该 key的 分区 ID，范围一定是 0~numPartitions-1。
3. equals(other: Any)：这个是 Java 标准的判断相等的函数，之所以要求用户实现这 个函数，是因为 Spark 内部会比较两个 RDD 的分区是否一样。
★难度：中
参见章节：第4章 第4节
考核知识点：数据分区
试题解析：
24、请说明SqlContext和HiveContext的区别
答案: SQLContext 现在只支持SQL 语法解析器，而HiveContext 现在不仅支持HiveQL 语法解析器，同时也支持SQL 语法解析器。
★难度：易
参见章节：第5章 第1节
考核知识点：Spark SQL概述
试题解析：
25、请简述创建DataFrame对象方式
答案: 1.结构化数据文件创建DataFrame
2.外部数据库创建DataFrame
3.RDD创建DataFrame
4.Hive中的表创建DataFrame
★难度：易
参见章节：第5章 第2节
考核知识点：DataFrame基础操作（1）
试题解析：
26、请简述Spark Streaming的运行原理
答案: Spark Streaming的输入数据按照时间片（batch size）分成一段一段的数据，得到批数据（batch data），每一段数据都转换成Spark中的RDD，然后将Spark Streaming中对DStream的Transformation操作变为针对Spark中的RDD的Transformation操作，将RDD经过操作变成中间结果保存在内存中。整个流式计算根据业务的需求可以对中间的结果进行叠加或者存储到外部设备。
★难度：中
参见章节：第6章 第1节
考核知识点：Spark Streaming概述
试题解析：
27、请概括使用Spark Streaming的四个基本步骤
答案: 1.创建StreamingContext对象
2.创建InputDStream
3. 操作DStream
4. 启动Spark Streaming
★难度：中
参见章节：第6章 第1节
考核知识点：Spark Streaming概述
试题解析：
28、请简述Dstream中的窗口函数及其作用
答案: 窗口函数，就是在DStream流上，以一个可配置的长度为窗口，以一个可配置的速率向前移动窗口，根据窗口函数的具体内容，对窗口内的数据执行计算操作，每次掉落在窗口内的RDD的数据会被聚合起来执行计算操作，然后生成的RDD会作为Window DStream的一个RDD。
★难度：中
参见章节：第6章 第3节
考核知识点：DStream编程模型（2）
试题解析：
29、请描述图计算应用中的淘宝图谱计算平台
答案: 如何将各种图的指标精细化和规范化，对于产品和运营的构思进行数据上的预研指导，提供科学决策的依据，是图谱计算平台设计的初衷和出发点。基于这样的出发点，淘宝借助GraphX丰富的接口和工具包，针对淘宝内部林林总总的图业务需求，开发了一个图谱计算平台。
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
30、请描述图计算应用中的Google的PageRank网页排名
答案: PageRank通过网络浩瀚的超链接关系来确定一个页面的等级。Google把从A页面到B页面的链接解释为A页面给B页面投票，Google根据投票来源（甚至来源的来源，即链接到A页面的页面）和投票目标的等级来决定新的等级。PageRank是通过网页之间的链接网络图计算网页等级的，是Google网页排名中的重要算法。
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
31、请描述图计算应用中的新浪微博社交网络分析
答案: 社交网络本身就是一个复杂的图关系结构的网络，最适合用图来表达和计算了，图的“顶点”表示社交中的人，“边”表示人与人之间的关系。如新浪微博社交网络分析，通过用户之间的关注、转发等行为建立了用户之间的社交网络关系图，根据用户在社交网络中所占位置为用户进行分析和应用。
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
32、请描述图计算应用中的淘宝、腾讯的推荐应用
答案: 如淘宝推荐商品，腾讯推荐好友等等，将商品之间的交互做成一张大的网络图，腾讯用户之间的关系做成一张社交网络图，在应用过程中就可以通过点与点之间的关系将与某商品相关的其他商品推荐给用户，或将朋友的朋友也推荐给你作为可能认识的人。
★难度：易
参见章节：第7章 第1节
考核知识点：Spark GraphX概述
试题解析：
33、请简述机器学习的分类
答案: 器学习可以分为监督学习、非监督学习、半监督学习 3 种。
监督学习就是给出的训练数据集是有标签的，已经能够确定所给数据集的类别。
半监督学习针对的问题是数据量 超级大但是标签数据很少或者标签数据不易获取的情况。
无监督学习与监督学习相反，训练数据完全没有标签，只能依靠数据间的相似性分类，例如广泛使用的 KMeans 算法
★难度：易
参见章节：第8章 第1节
考核知识点：MLlib算法库简介
试题解析：
34、请简述机器学习中降维算法的作用
答案: 主要作用是压缩数据与提升机器学习其他算法的效率。通过降维算法，可以将具有几千个特征的数据压缩至若干个特征。
★难度：易
参见章节：第8章 第1节
考核知识点：MLlib算法库简介
试题解析：
（四）、解答题
1、请阐述Spark在腾讯中的应用
难易程度：易
所属章节：1-3
考核知识点：Spark的应用场景
建议分值：4分
参考答案：
广点通是最早使用Spark的应用之一。腾讯大数据精准推荐借助Spark快速迭代的优势，围绕“数据+算法+系统”这套技术方案，实现了在“数据实时采集、算法实时训练、系统实时预测”的全流程实时并行高维算法，最终成功应用于广点通pCTR投放系统上，支持每天上百亿的请求量。
2、请阐述Spark在淘宝中的应用
难易程度：易
所属章节：1-3
考核知识点：Spark的应用场景
建议分值：4分
参考答案：
淘宝技术团队使用了Spark来解决多次迭代的机器学习算法、高计算复杂度的算法等，将Spark运用于淘宝的推荐相关算法上，同时还利用GraphX解决了许多生产问题，包括以下计算场景：基于度分布的中枢节点发现、基于最大连通图的社区发现、基于三角形计数的关系衡量、基于随机游走的用户属性传播等。
3、请阐述Spark在Yahoo中的应用
难易程度：易
所属章节：1-3
考核知识点：Spark的应用场景
建议分值：4分
参考答案：
Yahoo将Spark用在Audience Expansion中。Audience Expansion是广告中寻找目标用户的一种方法，首先广告者提供一些观看了广告并且购买产品的样本客户，据此进行学习，寻找更多可能转化的用户，对他们定向广告。Yahoo采用的算法是Logistic Regression。同时由于某些SQL负载需要更高的服务质量，又加入了专门跑Shark的大内存集群，用于取代商业BI/OLAP工具，承担报表/仪表盘和交互式/即席查询，同时与桌面BI工具对接。
4、请阐述Spark在优酷土豆中的应用
难易程度：易
所属章节：1-3
考核知识点：Spark的应用场景
建议分值：4分
参考答案：
目前Spark已经广泛使用在优酷土豆的视频推荐，广告业务等方面，相比Hadoop，Spark交互查询响应快，性能比Hadoop提高若干倍。一方面，使用Spark模拟广告投放的计算效率高、延迟小（同Hadoop比延迟至少降低一个数量级）。另一方面，优酷土豆的视频推荐往往涉及机器学习及图计算，而使用Spark解决机器学习、图计算等迭代计算能够大大减少网络传输、数据落地等的次数，极大地提高了计算性能。
5、请阐述Spark的生态圈
难易程度：易
所属章节：1-2
考核知识点：Spark的生态圈
建议分值：8分
参考答案：
（1）Spark Core：Spark核心，提供底层框架及核心支持。包含Spark的基本功能，包括任务调度、内存管理、容错机制等。
（2）BlinkDB：一个用于在海量数据上运行交互式SQL查询的大规模并行查询引擎。
（3）Spark SQL：可以执行SQL查询，包括基本的SQL语法和HiveQL语法。
（4）Spark Streaming：流式计算。
（5）MLBase：专注于机器学习，让机器学习的门槛更低，让一些可能并不了解机器学习的用户也能方便地使用MLBase。
（6）MLlib：MLBase的一部分，MLlib是Spark的数据挖掘算法库，实现了一些常见的机器学习算法和实用程序，包括分类、回归、聚类、协同过滤、降维以及底层优化。
（7）GraphX：内置了很多的图相关算法。
（8）SparkR：SparkR是AMPLab发布的一个R开发包，使得R摆脱单机运行的命运，可以作为Spark的Job运行在集群上，极大地扩展了R的数据处理能力。
6、请阐述Scala的特性
难易程度：中
所属章节：2-1
考核知识点：Scala简介及安装
建议分值：8分
参考答案：
面向对象
Scala 是一种纯粹的面向对象语言。一个对象的类型和行为是由类和特征来描述的。类通过子类化和基于灵活的混合类来进行扩展，作为多重继承的一个可靠性解决方案。
（2）函数式编程
Scala 提供了一个轻量级语法来定义匿名函数，它也支持高阶函数，允许函数嵌套，并支持柯里化。
Scala 的case class 与其内置的Pattern Matching 模型支持函数式编程语言中的代数类型。
Singleton 对象提供了一种方便的方法来组合不属于类的函数。
用户还可以使用Scala 的模式匹配，编写类似正则表达式的代码来处理XML 数据。
（3）静态类型
Scala 配备了一种表现型的系统，它以静态的方式进行抽象，以安全和连贯的方式进行使用。
系统支持通用类、内部类、抽象类和复合类作为对象成员，也支持隐式参数、转换和多态方法等。
（4）Scala 是可扩展的
Scala 提供了许多独特语言机制，可以以库的形式轻易无缝添加新的语言结构。
7、请阐述RDD的创建方式
难易程度：中
所属章节：3-1
考核知识点：创建RDD
建议分值：8分
参考答案：
（1）从集合中创建RDD
SparkContext 类中有两个方法: paralelize 和makeRDD 。通过parallelize 或makeRDD可将单机数据创建为分布式RDD 。这两种方法都是利用内存中已存在的集合，复制集合的元素去创建一个可用于并行计算的分布式数据集RDD 。
（2）从外部存储创建RDD
从外部读取数据创建RDD 可以有很多种数据来源，通过SparkContext 对象的textFile方法读取数据集，支持多种类型数据集，如目录、文本文件、压缩文件和通配符匹配的文件等，并且允许设定分区个数。
8、请阐述Spark对数据进行持久化的过程
难易程度：中
所属章节：4-3
考核知识点：持久化
建议分值：8分
参考答案：
（1）每个RDD一般情况下是由多个分区组成的，RDD的数据分布在多个节点中，所以Spark持久化一个RDD 时，是由参与计算该RDD 的节点各自保存自己所求出的分区数据。
（2）持久化RDD 后，在再一次需要计算该RDD 时将不需要重新计算，直接取各分区保存好的数据即可。
（3）如果其中有一个节点因为某种原因出现故障时， Spark 需要用到缓存数据时会重算丢失的分区，但不需要计算所有的分区。
（4）如果希望节点故障不影响执行速度，在内存充足的情况下，可以使用双副本保存的高可靠机制，这样其中一个副本有分区丢失的话，就会从另一个保存的副本中读取数据。
9、请阐述Spark对数据进行持久化的特点
难易程度：中
所属章节：4-3
考核知识点：持久化
建议分值：6分
参考答案：
（1） RDD 的存储级别应该根据需要以及环境具体情况设定，在RDD 参与第一次计算后，RDD 就会根据设置的存储级别保存RDD 计算后的值在内存中或磁盘上。
（2）只有未曾设置存储级别的RDD 才能设置存储级别，设置了存储级别的RDD 不能修改其存储级别。
（3）针对仅存储数据在内存中的存储策略，如果内存不足的话， Spark 会使用LRU 缓存策略清除最老的分区，为新的RDD 提供空间，所以缓存在内存中的RDD分区是会被清除的，而不能长久保存，而缓存在磁盘上的数据则不用担心。
（五）、编程题
1.题干：
def count(area:String) {
val arr= Array(“115036,1477799,广州,中国移动”,
“115038,1477801,东莞,中国联通”,
“115032,1477705,,广州,中国移动”)
Var sum=0
for(1. ;if a. 2. (area){
3.
Println(sum)
}
}
count(4. )
要求：本次的任务是以广州为例，统计广州号码段的数量。请补充空格处代码
难易程度：易
所属章节：2-4
考核知识点：Scala基础（3）
建议分值： 6分
参考答案：
a<-arr
contains
sum+=1
“广州”
评分标准：每个1.5分
2.题干：
def pascal(c:Int,r:Int): 1. ={
if(r==1) 1
else if(c==r) 1
else 2. +pascal(c-1,r)
}
for(3. to 5){
for(4. to col){
print(pascal(col,row)+” “)
}
println()
}
要求：上述代码采用Scala实现了杨辉三角。请补充空格处代码
难易程度：中
所属章节：2-3
考核知识点：Scala基础（2）
建议分值： 6分
参考答案：
Int
pascal(c-1,r-1)
col
row
评分标准：每个1.5分
3.题干：
def checkPhone{
val phone=for(line<-Source. 1. (“data.txt”).getlines)2. Line
val phoneList:List[String]=phone. 3.
val num:String = Console.readLine
for(4. ; if line.contains(num)){
println(line)
}
}
要求：上述代码是使用Scala编写手机号码归属地查询代码。请补充空格处代码
难易程度：中
所属章节：2-7
考核知识点：Scala类
建议分值： 6分
参考答案：
fromFile
yield
toList
line<-phoneList
评分标准：每个1.5分
4.题干：
scala> val bigdata = sc. 1. (“bigdata.txt”)
scala> val m_bigdata = bigdata.map{x=>val line = x.2. ; (line(0),line(1),line(2).3. )}
scala> val sort_bigdata = m_bigdata.sorBy(x=>4. , 5. )
scala>sort_bigdata.6. (5)
要求：上述代码是使用Spark编写程序去除成绩排名前五的学生成绩信息，要求 先将成绩表的RDD中的数据进行转换，每条数据被分成3列，表示学生ID、课程、成绩，分隔符为“\t”，存储为三元组格式，成绩要求转化为Int类型，可以直接通过toInt的转化。请补充空格处代码
难易程度：中
所属章节：3-2
考核知识点：RDD操作（1）
建议分值： 9分
参考答案：
textFile
Split(“\t”)
toInt
x._3
false
take
评分标准：每个1.5分
5.题干：
scala> val bigdata = sc. 1. (“bigdata.txt”)
scala> val math = sc. 1. (“math.txt”)
scala> val m_bigdata = bigdata.map{x=>val line = x.2. ; (line(0),line(1),line(2).3. )}
scala> val m_math = math.map{x=>val line = x.2. ; (line(0),line(1),line(2).3. )}
scala> val id_bigdata = m_bigdata.4. (x=>x._3==5. ).map(x=>6. )
scala> val id_math = m_math.4. (x=>x._3==5. ).map(x=>6. )
scala> val id = id_bigdata.7. (id_math). 8.
要求：上述代码是使用Spark编写程序找出单科成绩为100的学生ID，最终的结果需要集合到一个RDD中，这涉及两个RDD，一个是数学成绩RDD，一个是大数据成绩RDD，需要对两个RDD进行合并操作，要求先将成绩表的RDD中的数据进行转换，每条数据被分成3列，表示学生ID、课程、成绩，分隔符为“\t”，存储为三元组格式，成绩要求转化为Int类型，可以直接通过toInt的转化。请补充空格处代码
难易程度：中
所属章节：3-3
考核知识点：RDD操作（2）
建议分值： 12分
参考答案：
textFile
Split(“\t”)
toInt
filter
100
x._1
union
distinct()
评分标准：每个1.5分
6.题干：
scala> val bigdata = sc. 1. (“bigdata.txt”)
scala> val math = sc. 1. (“math.txt”)
scala> val m_bigdata = bigdata.map{x=>val line = x.2. ; (line(0),line(1),line(2).3. )}
scala> val m_math = math.map{x=>val line = x.2. ; (line(0),line(1),line(2).3. )}
scala> val all_score = m_bigdata4. m_math
scala> val score = all_score.map(x=>(x._1, x._3)).5. ((a,b)=>6. )
要求：上述代码是使用Spark编写程序输出每位学生的总成绩，要求将两个成绩表中学生ID相同的成绩相加，并要求先将成绩表的RDD中的数据进行转换，每条数据被分成3列，表示学生ID、课程、成绩，分隔符为“\t”，存储为三元组格式，成绩要求转化为Int类型，可以直接通过toInt的转化。请补充空格处代码
难易程度：中
所属章节：3-4
考核知识点：RDD操作（3）
建议分值： 9分
参考答案：
textFile
Split(“\t”)
toInt
union
reduceByKey
a+b
评分标准：每个1.5分
7.题干：
scala> val bigdata = sc. 1. (“bigdata.txt”)
scala> val math = sc. 1. (“math.txt”)
scala> val m_bigdata = bigdata.map{x=>val line = x.2. ; (line(0),line(1),line(2).3. )}
scala> val m_math = math.map{x=>val line = x.2. ; (line(0),line(1),line(2).3. )}
scala> val score = m_bigdata. 4. (m_math).map(x=>(x._1, x._2))
scala> val cb_score = scores. 5. (
| count => (count,1),
| (acc: (Int, Int), count) =>(acc._1+count, acc._2+1),
| (acc1: (Int, Int), acc2:(Int, Int)) =>(acc1._1+acc2._1, acc1._2+acc2._2))
)
scala> val avg_score = cb_score. 6. (x=>(x._1, x._2._1.toDouble/x._2._2))
要求：上述代码是使用Spark编写程序计算每个学生的平均成绩，要求读取成绩表创建RDD，通过map转化得到学生ID和score两列数据的RDD，学生ID作为键，score作为值，并要求先将成绩表的RDD中的数据进行转换，每条数据被分成3列，表示学生ID、课程、成绩，分隔符为“\t”，存储为三元组格式，成绩要求转化为Int类型，可以直接通过toInt的转化。请补充空格处代码
难易程度：中
所属章节：3-5
考核知识点：RDD操作（4）
建议分值： 9分
参考答案：
textFile
Split(“\t”)
toInt
union
combineByKey
map
评分标准：每个1.5分
8.题干：
import org.apache.spark.Partitioner
class MyPartition(numParts:Int) extends 1. {
override def numPartitions: 2. = numParts
override def getPartition(key: 3. ): Int = {
if(key.toString().toInt % 2 ==0) {
0
} else
{
1
}
}
override def equals(other: Any) : 4. =other match{
case mypartition: MyPartition => mypartition.numPartitions == numPartitions
case _=>false
}
}
要求：上述代码是使用Spark编写程序自定义一个分区器 MyPartition，要求根据键的奇偶性将数据分布在两个分区中。请补充空格处代码
难易程度：中
所属章节：4-4
考核知识点：数据分区
建议分值： 6分
参考答案：
Partitioner
Int
Any
Boolean
评分标准：每个1.5分
9.题干：
package demo.stock
import org.apache.spark.{SparkConf,SparkContext}
import java.text.SimpleDateFormat
import scala.collection.mutable
object CalculateChange {
def main(args: Array[String]) {
val conf = new SparkConf().1. (“calculate zhangfu”)
val sc = new 2. (conf)
val input = args(0)
val output = args(1)
val splitter = args(2)
val fm = new SimpleDateFormat(“yyyy-MM-dd”)
val data = sc.textFile(input).3. (x => !x.contains(“date”)).4. {x=>
val split_data = x.split(splitter);
val timestamp = fm.parse(split_data(0));
(timestamp.getTime(),(split_data(0),split_data(3).toDouble))
}.filter(x=>x._2._2!=0).sortByKey().map(x=>(x._2._1,x._2._2))
val queue = new mutable.Queue[Double]()
val percentFormat = java.text.NumberFormat.getPercentInstance
val zhangfu = data.map { x =>
queue.enqueue(x._2);
if (queue.size == 2) {
val cha = (queue.last – queue.head) / queue.head;
queue.dequeue();
(x._1, cha)
}
else {
(0, 0)
}
}
val result = zhangfu.filter(x=>x._1!=0).map(x=>x._1+”,”+x._2)
result.repartition(1).saveAsTextFile(output)
}
}
要求：上述代码是使用Spark编写程序计算股票的价格涨幅。请补充空格处代码
难易程度：中
所属章节：4-5
考核知识点：练习——计算价格波动幅度
建议分值： 6分
参考答案：
setAppName
SparkContext
filter
map
评分标准：每个1.5分
10.题干：
package demo.stock
import org.apache.spark.Partitioner
class DatePartition extends 1. {
override def numPartitions: 2. = 4
override def getPartition(key: 3. ): Int = {
val date = key.toString().substring(0,4).trim()
if (date==”2013″) {
0
}
else if(date==”2014″){
1
}
else if(date==”2015″){
2
}else{
3
}
}
override def equals(other: Any): 4. = other match {
case datepartition: DatePartition =>
datepartition.numPartitions == numPartitions
case _ =>
false
}
}
要求：上述代码是使用Spark编写程序自定义一个分区器 DatePartition，要求根据日期的年份对数据分区。请补充空格处代码
难易程度：中
所属章节：4-5
考核知识点：练习——计算价格波动幅度
建议分值： 6分
参考答案：
Partitioner
Int
Any
Boolean
评分标准：每个1.5分
11.题干：
package demo.stock
import java.text.SimpleDateFormat
import org.apache.spark.{Partitioner, SparkConf, SparkContext}
import scala.collection.mutable
import org.apache.spark.storage.StorageLevel
object MovingAverage {
def main(args: Array[String]) {
val conf = new SparkConf().1. (“MovingAverage”)
val sc = new 2. (conf)
val input = args(0)
val output = args(1)
val splitter = args(2)
val brodcastWindow = args(3).toInt
val output2 = args(4)
val fm = new SimpleDateFormat(“yyyy-MM-dd”)
val data = sc.textFile(input).map{x=>
val split_data = x. 3. (splitter);
val timestamp = fm.parse(split_data(0));
(timestamp.getTime(),(split_data(0),split_data(1).toDouble))
}.sortByKey().map(x=>(x._2._1,x._2._2))
val queue = new mutable.Queue[Double]()
val yucezhangfu = data. 4. {x=>
queue.enqueue(x._2)
if(queue.size>brodcastWindow){
val ave = (queue.sum-x._2)/brodcastWindow;
queue.dequeue();
(x._1,ave,x._2)
}
else{(0,0,0)}
}.filter(x=>x._1!=0).persist(StorageLevel.MEMORY_AND_DISK)
yucezhangfu.map(x=>(x._1,(x._2,x._3))).partitionBy(new DatePartition()).saveAsTextFile(output)
yucezhangfu.map(x=>(x._1,x._2)).partitionBy(new DatePartition()).saveAsTextFile(output2)
}
}
要求：上述代码是使用Spark编写程序计算股票的价格涨幅，此段代码实现移动平均的计算类MovingAverage ，在类中设置数据分区方法为向定义的分区器DatePartition。请补充空格处代码
难易程度：中
所属章节：4-5
考核知识点：练习——计算价格波动幅度
建议分值： 6分
参考答案：
setAppName
SparkContext
spilt
map
评分标准：每个1.5分
12.题干：
import org.apache.spark.streaming.StreamingContext
import org.apache.spark.streaming.StreamingContext._
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.Duration
import org.apache.spark.streaming.Seconds
//设置日志级别
sc. 1. (“WARN”)
//从SparkConf创建StreamingContext并指定1s的批处理大小
val ssc=new 2. (sc,Seconds(1))
//启动连接到slave1 8888端口上，使用收到的数据创建DStream
val lines=ssc. 3. (“slave1″,8888)
val words=lines.flatMap(_.split(” “))
val wordCounts=words.map(x=>(x,1)).reduceByKey(_+_)
wordCounts.print()
//启动流计算环境StreamingContext
ssc. 4. ()
要求：上述代码是使用Spark编写程序使用SparkStreaming。请补充空格处代码
难易程度：中
所属章节：6-1
考核知识点：Spark Streaming概述
建议分值： 6分
参考答案：
setLogLevel
StreamingContext
socketTextStream
start()
评分标准：每个1.5分
13.题干：
import org.apache.spark.streaming.{ 1. , StreamingContext}
import org.apache.spark.streaming.StreamingContext._
val ssc=new 2. (sc,Seconds(1))
ssc.checkpoint(“hdfs://master:8020/spark/checkpoint”)
val lines=ssc. 3. (“slave1″,8888)
val words=lines.flatMap(_.split(” “))
val pairs=words.map(word=>(word,1))
val windowWords=pairs.reduceByKeyAndWindow((a:Int,b:Int)=>(a+b),Seconds(3), Seconds(1))
windowWords.print()
ssc.start()4. ()
要求：上述代码是使用Spark编写程序使用DStream窗口操作将当前长度为3的时间窗口中的所有数据元素根据key进行合并，统计当前3秒中内不同单词出现的次数。请补充空格处代码
难易程度：中
所属章节：6-3
考核知识点：DStream编程模型（2）
建议分值： 6分
参考答案：
Seconds
StreamingContext
socketTextStream
start
评分标准：每个1.5分
14.题干：
import java.sql.{Connection, DriverManager, PreparedStatement}
import org.apache.spark.SparkConf
import org.apache.spark.streaming
import org.apache.spark.streaming._
import org.apache.spark.streaming.Seconds
object WriteDataToMysql {
def main(args:Array[String]):Unit={
val conf=new SparkConf().setMaster(“local[3]”).setAppName(“WriteDataToMySQL”)
val ssc=new StreamingContext(conf,Seconds(5))
val ItemsStream=ssc.socketTextStream(“slave1”,8888)
val ItemPairs=ItemsStream.map(line=>(line.split(“,”)(0),1))
val ItemCount=ItemPairs.reduceByKeyAndWindow((v1:Int,v2:Int)=>v1+v2,Seconds (60),Seconds(10))
val hottestWord=ItemCount. 1. (itemRDD=>{
val top3=itemRDD.map(pair=>(pair._2,pair._1)).sortByKey(false).map(pair=> (pair._2,pair._1)).take(3)
ssc.sparkContext.makeRDD(top3)
})
hottestWord.foreachRDD(rdd=>{
rdd.foreachPartition(partitionOfRecords=>{
val url=”jdbc:mysql://192.168.128.130:3306/spark”
val user=”root”
val password=”root”
Class.forName(“com.mysql.jdbc.Driver”)
val conn=DriverManager. 2. (url,user,password)
conn.prepareStatement(“delete from searchKeyWord where 1=1”).executeUpdate()
conn.setAutoCommit(false)
val stmt=conn.createStatement()
partitionOfRecords.foreach(record=>{
stmt.addBatch(“insert into searchKeyWord (insert_time,keyword,search_count) values (now(),'”+record._1+”‘,'”+record._2+”‘)”)
})
stmt.executeBatch()
conn. 3. ()
})
})
ssc. 4. ()
ssc.awaitTermination()
ssc.stop()
}
}
要求：上述代码是使用Spark编写程序，设置窗口长度为60秒，窗口滑动时间间隔为10秒，计算10秒内每个单词出现的次数，然后根据出现的次数对单词进行排序。请补充空格处代码
难易程度：中
所属章节：6-3
考核知识点：DStream编程模型（2）
建议分值： 6分
参考答案：
transform
getConnection
commit
start
评分标准：每个1.5分
15.题干：
import java.sql.{Connection, DriverManager}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
object PageHot {
def main(args:Array[String])={
val sc=new SparkConf().setMaster(“local[4]”). 1. (“pagehot”)
val ssc=new StreamingContext(sc,Seconds(5))
val lines=ssc.textFileStream(“E:\\streaming”)
//计算网页热度
val html=lines.map{line=>val words=line.split(“,”);(words(0),0.1*words(1). toInt+0.9*words(2).toInt+0.4*words(3).toDouble+words(4).toInt)}
//计算每个网页的热度总和
val htmlCount=html.reduceByKeyAndWindow((v1:Double,v2:Double)=>v1+v2,Seconds (60),Seconds(10))
//按照网页的热度总和降序排序
val hottestHtml=htmlCount.transform(itemRDD=>{
val top10=itemRDD.map(pair=>(pair._2,pair._1)).sortByKey(false).map (pair=>(pair._2,pair._1)).take(10)
ssc.sparkContext.makeRDD(top10).repartition(1)
})
hottestHtml.foreachRDD(rdd=>{
rdd. 2. (partitionOfRecords=>{
val url=”jdbc:mysql://192.168.128.130:3306/spark”
val user=”root”
val password=”root”
val conn=getConn(url,user,password)
delete(conn,”top_web_page”)
conn.setAutoCommit(false)
val stmt=conn.3. ()
var i=1
partitionOfRecords.foreach(record=>{
println(“input data is “+record._1+” “+record._2)
stmt.addBatch(“insert into top_web_page(rank,htmlID,pageheat) values (‘”+i+”‘,'”+record._1+”‘,'”+record._2+”‘)”)
i+=1
})
stmt.executeBatch()
conn.commit()
})
})
ssc. 4. ()
ssc.awaitTermination()
ssc.stop()
}
def getConn(url:String,user:String,password:String):Connection={
Class.forName(“com.mysql.jdbc.Driver”)
val conn=DriverManager.getConnection(url,user,password)
return conn
}
def delete(conn:Connection,table:String)={
val sql=”delete from “+table+” where 1=1″
conn.prepareStatement(sql).executeUpdate()
}
}
要求：上述代码是使用Spark编写程序，设置窗口长度为60秒，窗口滑动时间间隔为10秒，计算10秒内每个单词出现的次数，然后根据出现的次数对单词进行排序。请补充空格处代码
难易程度：中
所属章节：6-4
考核知识点：练习——实时更新热门博文
建议分值： 6分
参考答案：
setAppName
foreachPartition
createStatement
start
