一、单项选择题
1、下面哪个操作是窄依赖？（B）
窄依赖是指1个父RDD分区对应1个子RDD的分区。换句话说，一个父RDD的分区对应于一个子RDD的分区，或者多个父RDD的分区对应于一个子RDD的分区。所以窄依赖又可以分为两种情况：
1个子RDD的分区对应于1个父RDD的分区，比如map，filter，union等算子
1个子RDD的分区对应于N个父RDD的分区，比如co-partioned join
A、join
B、filter
C、group
D、sort
2、不属于Scala 7种数据类型之一的是？（D）
Scala支持数据类型：Byte、Short、Int、Long、Float、Double、Char
A、Char
B、Int
C、Float
D、LongLong
3、在Scala中如何获取字符串”Hello”的首字符和尾字符？（B）
A、”Hello”(0),”Hello”(5)
B、“Hello”.take(1),”Hello”.reverse(0)
C、“Hello”(1),”Hello”(5)
D、“Hello”.take(0),”Hello”.takeRight(1)
4、Scala 允许用数学去乘字符串，在REPL中输入”crazy”*3,这个操作结果返回什么？（C）
A、”crazy”*3
B、ccrraazzyy
C、crazycrazycrazy
D、crazy
5、RDD和DataFrame最大的区别是？（B）
RDD创建之后你知道他有这个类，但是你不知道它的内部结构，但是DataFream是以列式储存，它有schema（[ˈskiːmə]）是可以知道的（schema描述：按列存储，有对应列的描述（相当于数据结构））
其他不同点：（1）DataFream比RDD执行效率更高一些，因为在大数据的处理中，RDD即使用mappartition或者foreachRDD都要消耗不少的core（处理器），但是DataFrame他可以进行sql操作，先过滤掉一部分数据，在RDD中是不好实现的。（2）SpakSQL在执行的时候是有底层优化的
函数式编程：
GC:
DataFream的概念：
1）分布式的数据集，并且以列的方式组合的。相当于具有schema的RDD
2）相当于关系型数据库中的表，但是底层有优化
3）提供了一些抽象的操作，如select、filter、aggregation、plot
4）它是由于R语言或者Pandas语言处理小数据集的经验应用到处理分布式大数据集上
5）在1.3版本之前，叫SchemaRDD
A、科学统计支持
B、多了schema
C、存储方式不一样
D、外部数据源支持
6、Spark中默认的存储级别（A）
Spark中默认的存储级别:MEMORY_ONLY
A、MEMORY_ONLY
B、MEMORY_ONLY_SER
C、MEMORY_AND_DISK
D、MEMORY_AND_DISK_SER
7、编写一个过程countdown(n:Int),打印从n到0的数字？（C）
A、def countdown(n:Int){
0 to n foreach print
}
B、def countdown(n:Int){
(0 until n ).reverse foreach print
}
C、def countdown(n:Int){
0 to n reverse foreach print
}
D、def countdown(n:Int){
(0 to n-1) reverse foreach print
}
8、下面哪个属于Spark组成部件？（B）
A、Resource Manager
B、Executor
C、RDD //核心数据结构
D、Cllent
9、下面哪个不是RDD的特点？（D）
spark是粗粒度资源申请，也就是当提交spark application的时候，application会将所有的资源申请完毕，如果申请不到资源就等待，如果申请到资源才执行application，task在执行的时候就不需要自己去申请资源，task执行快，当最后一个task执行完之后task才会被释放。优点是执行速度快，缺点是不能使集群得到充分的利用
MapReduce是细粒度资源申请，当提交application的时候，task执行时，自己申请资源，自己释放资源，task执行完毕之后，资源立即会被释放，task执行的慢，application执行的相对比较慢。
优点是集群资源得到充分利用，缺点是application执行的相对比较慢。Spark是基于内存的，而MapReduce是基于磁盘的迭代
A、不支持增量迭代计算
B、基于内存的计算
C、没有schema信息
D、支持细粒度的写和更新
10、对于函数
Def getGoodsPrice(goods:String)={
Val prices = Map (“book”-> 5 ,”pen” -> 2,”sticker” ->1)
Prices.getOrElse(goods,0)//没有就为0
}
结果说法错误的是？（D）
A、getGoodsPrice(“book”)//等于5
B、getGoodsPrice(“pen”)//等于2
C、getGoodsPrice(“sticker”)//等于1
D、getGoodsPrice(“sock”)//等于”sock” //0
二、填空题
1、最早是Cloudera提供的日志收集系统，目前是Apache下的一个孵化项目，支持在日志系统中定制各类数据发送方，用于收集数据的工具是_____flum___________;一个分布式应用程序协调服务，分布式应用程序可以基于它实现同步服务，配置维护和命名服务等的工具是___Zookeeper_______;作为分布式信息队列，既有非常优秀的吞吐量，又有较高的可靠性和扩展性，同时接受Spark Streaming 的请求，将流量日志按序发送给Spark Streaming 集群是____Kafka_________。
2、写出四种Spark的部署模式___local模式（本地模式）、standalone模式（集群模式）、_ yarn模式（集群模式）_____、Mesos模式（集群模式）。
1.Local模式
Local模式就是运行在一台计算机上的模式，通常用于在本机上测试，当不设置master参数的值时，默认此模式，具体有以下几种设置master的方式。
（1）local：所有计算都运行在一个线程当中，没有任何并行计算。
（2）local[n]：指定使用n个线程来运行计算。
（3）local[*]：按照CPU的最多核数来设置线程数。
2.Standalone模式
设置master参数的值为spark://host:port，即开启Standalone模式，将构建一个基于Master/Slave的资源调度集群，Spark任务提交给Master运行。
3.Yarn模式
Spark客户端直接连接Yarn，不需要格外构建Spark集群，有yarn-client和yarn-cluster两种模式，主要区别在于Driver程序的运行节点不同（yarn-client的Driver程序运行在客户端，适用于交互、调试，而yarn-cluster的Driver程序运行在由ResourceManager启动的ApplicationMaster中，适用于生产环境）。master参数设置为yarn，deploy-mode参数为client或者cluster。
4.Mesos模式
Spark客户端直接连接Mesos，不需要额外构建Spark集群。
在Spark的后续版本中，已经支持连接到Kubernetes集群。
这四种模式的差别在于资源管理者是谁。
3、定义一个类Counter,类里包含两个变量name,age 变量类型分别为String和Int的代码：
Class Counter _________________________________________________。
var String name;
var int age;
4、函数 def fac(n:Int) = { var r = 1; for(i <- 1 to n )r = r * i :r} fac(5)输出结果是__120。
5、Scala的方法的参数都是____val_______类型，因此在函数体内不可以修改参数的值。
6、通过如下语句创建了一个____SparkSession__________对象：
Scala>import org.apache.spark.sql.SparkSession
Scala>val spark = SparkSession.builder().getOrCreate();
三、判断题
1、RDD叫做弹性分布式数据集，是分布式内存的一个抽象概念，提供了一种 高度受限的共享内存模型。（ T ）
2、基于分布式计算的框架是spark比Mapreduce计算快的原因之一。（ F ）
3、Spark最大的特点就是将计算数据、中间结果都存储在内存中，大大减少I/O开销。（F ）
4、关于辅助构造器，辅助构造器必须要带参数。（T ）
(实例：D:\project\sparktwo\src\main\scala\project1230\project2.scala)
5、Scala中可以将函数赋值给变量，如 val fun = scala.math.cell。( F )
val类似于Java里面的final变量，可以将val类型的变量简单记忆为value（数值）类型的变量，一旦初始化，val就不能再被赋予新值了，就相当于一旦赋予一个val类型的变量（比如，定义一张纸币一定的价值）具体的值，就无法再改变其值了。
6、Spark 的四大组件分别是Spark Streaming、Spark MLlib、YARN、SparkSQL。（ F ）
Spark提供了一系列面向不同应用需求的组件，主要有Spark SQL、Spark Streaming、MLlib、GraphX。
7、transformation和action是Spark支持的两种RDD操作。（ F ）
一个完整的RDD任务由两部分组成：Transformation和 Action。Transformation用于对RDD的创建，还可以把老的RDD通过Transformation来生成新的RDD。例如，map就 是一种transformation操作，它用于将已有RDD的每个元素传入一个自定义的函数，并得到一个新的元素，然后将所有的新元素组成一个新的 RDD。但RDD一大特性是延迟（lazy）计算，即纵使你执行这些Transformation操作，这些操作也不会执行。换句话说， transformation操作不会触发spark程序执行的，它们只是先记录了对RDD所做的一系列操作，只有之后碰上一个action操作，那么前 面所有的transformation才会执行。collect和reduce就是action操作。
8、对于代码class Cat extends Animal{ }来讲，Cat是Animal的超类。（ F ）
在软件术语中，被继承的类一般称为“超类”，也有叫做父类。
9、Scala中接口称为特质，跟java中的接口一样，特质中不可以有构造器。（ F ）
Java的接口与Scala的trait特质
接口不会有构造器，特质可以有构造器，并且在实现类继承特质的时候，先要调用特质的构造器。
10、类和单例对象间的差别是单例对象不可以带参数，而类可以。（ F ）
一、spark比Mapreduce计算快的原因
*1、spark是基于内存进行数据处理的，MapReduce是基于磁盘进行数据处理的
MapReduce的设设计：中间结果保存在文件中，提高了可靠性，减少了内存占用。但是牺牲了性能。
Spark的设计：数据在内存中进行交换，要快一些，但是内存这个东西，可靠性不如磁盘。所以性能方面比MapReduce要好。
DAG计算模型在迭代计算上还是比MapReduce的效率更高
2、spark中具有DAG有向无环图，DAG有向无环图在此过程中减少了shuffle以及落地磁盘的次数
Spark 计算比 MapReduce 快的根本原因在于 DAG 计算模型。一般而言，DAG 相比MapReduce 在大多数情况下可以减少 shuffle 次数。Spark 的 DAGScheduler 相当于一个改进版的 MapReduce，如果计算不涉及与其他节点进行数据交换，Spark 可以在内存中一次性完成这些操作，也就是中间结果无须落盘，减少了磁盘 IO 的操作。但是，如果计算过程中涉及数据交换，Spark 也是会把 shuffle 的数据写磁盘的！有一个误区，Spark 是基于内存的计算，所以快，这不是主要原因，要对数据做计算，必然得加载到内存，Hadoop 也是如此，只不过 Spark 支持将需要反复用到的数据给 Cache 到内存中，减少数据加载耗时，所以 Spark 跑机器学习算法比较在行（需要对数据进行反复迭代）。Spark 基于磁盘的计算也是比 Hadoop 快。刚刚提到了 Spark 的 DAGScheduler 是个改进版的 MapReduce，所以 Spark天生适合做批处理的任务。Hadoop 的 MapReduce 虽然不如 spark 性能好，但是 HDFS 仍然是业界的大数据存储标准。
3、spark是粗粒度资源申请，也就是当提交spark application的时候，application会将所有的资源申请完毕，如果申请不到资源就等待，如果申请到资源才执行application，task在执行的时候就不需要自己去申请资源，task执行快，当最后一个task执行完之后task才会被释放。
优点是执行速度快，缺点是不能使集群得到充分的利用
MapReduce是细粒度资源申请，当提交application的时候，task执行时，自己申请资源，自己释放资源，task执行完毕之后，资源立即会被释放，task执行的慢，application执行的相对比较慢。
优点是集群资源得到充分利用，缺点是application执行的相对比较慢。
Spark是基于内存的，而MapReduce是基于磁盘的迭代
有向无环图是指：一个图从顶点出发，无法再回到原点，那么这种图叫做有向无环图。
DAG计算模型在spark任务调度
Spark是粗粒度资源调度，MapReduce是细粒度资源调度*
二、辅助构造器：
1.辅助构造器的名称为this。
2.每个辅助构造器都必须以一个对先欠已经定义的其他构造器调用先开始。
三、Spark 的四大组件
1、Spark SQL
用Spark来操作结构化数据的程序包。可以使用SQL或Hive的HQL来查询数据，并可以与RDD的操作相结合使用。
2、Spark Streaming
用来对实时数据进行流式计算的组件，Streaming中提供操作流式数据的API与RDD高度对应。Streaming与日志采集工具Flume、消息处理Kafka等可集成使用。
3、 MLib
机器学习（ML）的功能库，提供多种学习算法，包括分类、回归、聚类、协同过滤等，还提供了模型评估、数据导入等功能。
4、 GraphX
用来操作图的程序库，可以用于并行的图计算。扩展了RDD API功能，用来创建一个顶点和边都包含任意属性的有向图。支持针对图的各种操作，如图的分割subgraph、操作所有的顶点mapVertices、三角计算等。
四、简答题
1、下列JSON格式数据命名为employee.json，文件路径“usr/local/spark/examples/employee.json”。
{“id” : 1 , “name”: “Ella” , “age”: 36}
{“id” : 2 , “name”: “Bob” , “age”: 29}
{“id” : 3 , “name”: “Jack” , “age”: 29}
{“id” : 4 , “name”: “Jim” , “age”: 28}
{“id” : 4 , “name”: “Jim” , “age”: 28}
{“id” : 5 , “name”: “Damon” }
{“id” : 5 , “name”: “Damon” }
为employee.json创建DataFrame，并写出Scala语句完成下列操作：
（1）查询所有数据，并去除重复的数据；
（2）查询所有数据，打印时去除id字段；
（3）筛选出age>30的记录；
（4）查询所有记录的name列，并为其取名为username；
（5）查询年龄age的平均值。
package project1230
import org.apache.spark.sql.{DataFrame, SQLContext}
import org.apache.spark.{SparkConf, SparkContext}
/**
* @program: sparktwo
* @description
* @author: livia
* @create: 2019-12-30 19:29
**/
object project3 {
def main(args: Array[String]): Unit = {
val sc =new SparkContext(new SparkConf().setAppName("SparkSQL").setMaster("local[*]"))
//创建SQLContext对象
val sqlc = new SQLContext(sc)
val df: DataFrame = sqlc.read.json("txt/1230project3.json")
//使用Sql语法
//注册临时表，这个表相当于存储在 SQLContext中所创建对象中
df.registerTempTable("t_person")
//1 查询所有数据，并去除重复的数据；
val sql = "select distinct * from t_person"
//2 查询所有数据，打印时去除id字段；
val sql2 = "select id,name from t_person"
//3 筛选出age>30的记录；
val sql3 = "select * from t_person where age>30"
//4 查询所有记录的name列，并为其取名为username
val sql4 = "select name as username from t_person"
// 5 查询年龄age的平均值
val sql5 = "select avg(age) from t_person"
//查询
val res = sqlc.sql(sql5
)
res.show() //默认打印是20行
}
case class Person(id:Int,name:String,age:Int)
}
2、spark中的RDD是什么，有哪些特征？
RDD（Resilient Distributed Dataset）叫做分布式数据集，是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合。
Dataset：就是一个集合，用于存放数据的
Distributed：分布式，可以并行在集群计算
Resilient：表示弹性的（RDD中的数据可以存储在内存或者是磁盘）
RDD五大特性：
1.RDD是由一系列的partition组成的
2.RDD之间具有依赖关系
3.RDD作用在partition是上
4.partition作用在具有（k,v）格式的数据集
5.partition对外提供最佳计算位置，利于数据本地化的处理
3、阅读下面这段代码
Def joinRdd(sc:SparkContext) {
Val name = Array(
Tuple2(1,”spark”),
Tuple2(2,”tachyon”),
Tuple2(3,”hadoop”),
)
Val score = Array(
Tuple2(1,100),
Tuple2(2,90),
Tuple2(3,80),
)
Val namerdd = sc.parallelize(name);
Val scorerdd = sc.parallelize(score);
【代码】
}
写出【代码】处填入以下代码时的输出结果。
（1）val result = namerdd.join(scorerdd);
（2）Result.collect.foreach(println);
（3）Result.count();
（4）Result.take(3)
五、编程题
1、如何使用Spark解决分组排序问题？
组织数据形式
aa 11
bb 11
cc 34
aa 22
bb 67
cc 29
aa 36
bb 33
cc 30
aa 42
bb 44
cc 49
需求：
1、对上述数据按Key值进行分组；
2、对分组后的值进行排序；
3、截取分组后的值top3位一key-value 形式返回结果。
Val groupTopNRdd = sc.textFile(“hdfs://db02:8020/user/hadoop/groupsorttop/groupsorttop.data “)
2、编程实现将RDD转换为DataFrame
源文件是在“/usr/local/spark/”目录中的student.txt文件，其内容如下（每行数据从左到右分别是 id,name,score）：
1：张三：87
2：李四：88
3：王五：55
请将student.txt加载到内存中生成一个DataFrame,并按“id:1,name:张三，score:87”的格式打印出DataFrame的所有数据。
3、写出一个Spark Streaming 程序，监控某目录中的文件，指定监控的目录为“/home/hadoop/temp/”，其能获取在该间隔时间段内变化的数据，例如在文件里新增一部分单词（单词之间用空格隔开），然后通过计算得出改时间段内的单词统计数。
部分代码已给出。
Import org.apache.spark.SparkConf
Import org.apache.spark.streaming.{Seconds,StreamingContext}
Import org.apache.spark.steaming.StreamingContext._
Object FileWordCount {
Def main(args:Array[String]) {