1.Spark & MR相对速度快的原因？
1).Spark可以基于内存处理数据，MR基于磁盘处理数据。
2).Spark中有DAG有向无环图

3).Spark多个任务之间数据通信是基于内存，而Hadoop是基于磁盘。

总结:在处理数据的时候,Spark中的job会使用前一个在内存中存放的rdd,这样的就不会有

2.完成Spark java版本WordCount & Scala版本WordCount 编写，默写Scala版本。

1)首先配置Maven,创建IDEA Maven,配置Pom.xml文件

2)开发代码

scala版本:

sc.textFile(....).flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).foreach(println)

3.Spark的运行模式有哪些?
local：多用于本地测试，如在eclipse，idea中写程序测试等。
standalone:是Spark自带的一个资源调度框架，它支持完全分布式。
yarn:Hadoop生态圈里面的一个资源调度框架，Spark也是可以基于Yarn来计算的。
mesos:资源调度框架。

4.Spark核心RDD
1).什么是RDD?
Resilient Distributed Dateset 弹性分布式数据集
2).RDD的五大特性？
a.RDD由一系列partition组成
b.算子（函数）是作用在Partiton上的
c.RDD之间有依赖关系
d.分区器是作用在K,V格式的RDD上。
e.partition对外提供最佳的计算位置，利于数据处理的本地化。

3).Spark RDD需要注意的问题
a.sc.textFile(…)读取HDFS文件的方法底层调用的是MR读取HDFS文件的方法，首先split,每个split对应一个block，这里每个
split对应一个partition。
b.什么是K,V格式的RDD?
当RDD中的数据是一个个的tuple2时，这个RDD就叫做K,V格式的RDD
C.哪里体现RDD的分布式？
RDD中partition是分布在多个节点上的
d.哪里体现RDD的弹性：
1).RDD之间有依赖关系
2).RDD的分区数可多可少

5.Spark 算子分为哪几类？
a.Transformations 算子 - 转换算子
flatMap，map ,filter,sortBy，sortByKey,redueByKey，sample

b.Action算子 - 行动算子 ,有一个action算子就有一个job
foreach ,take(num),first = take(1) ,collect(),count()

c.持久化算子
cache() ：
默认将数据放在内存中，懒执行，需要action算子触发执行。
cache() = persist() = persist(StorageLevel.MEMORY_ONLY)
persist()
可以手动指定持久化级别
常用的级别：
MEMORY_ONLY
MEMORY_ONLY_SER
MEMORY_AND_DISK
MEMORY_AND_DISK_SER
注意：避免使用DISK_ONLY 和“_2”级别。

checkpoint()
1).checkpoint 执行流程
优化：对哪个RDD进行checkpoint时，最好先cache下。
2).checkpoint 将数据存储在磁盘，persist(StorageLevel.DISK_ONLY)

6.Spark代码执行的流程?
a.SparkConf
b.SparkContext
c.创建RDD
d.对RDD使用transformation算子转换
e.对RDD使用action算子触发执行
f.sc.stop()

- 1.val conf = new SparkConf()  ; conf.setMaster.. ;conf.setAppName()  
- 2.val sc = new SparkContext(conf)  
- 3.val rdd = sc.textFile...  
- 4.对RDD使用RDD的Transformation类算子进行转换  
- 5.对RDD要使用Action类算子触发Transformation类算子执行  
- 6.sc.stop()

8.Spark 持久化算子

cache

默认将数据持久化到内存中

cache() = persist() = persist(StorageLevel.MEMORY_ONLY)

persist

1.可以手动指定持久化级别

2.常用的持久化级别

1)MEMORY_ONLY

2)MEMORY_ONLY_SER

3)MEMORY_AND_DISK

4)MEMORY_AND_DISK_SER

3.避免使用DISK_ONLY 和 “_2” 级别

checkpoint

1.当job的lineage非常长，计算非常复杂时，可以对RDD进行checkpoint，将RDD的数据持久化到磁盘

2.checkpoint & persist(DISK_ONLY)

1).persist 将数据持久化起来之后，当application执行完成之后，持久化的数据会被清空

2).checkpoint将数据持久化到磁盘，数据由外部的存储系统管理，当application执行完成之后，数据不会被清空

3).checkpoint常用作保存状态，在SparkStreaming有更好体现

3.checkpoint懒执行，持久化单位也是partition

注意

  • cache & persist
  • 1.cache() persist() 都是懒执行，需要action算子触发执行
    2.对RDD进行持久化时，可以直接cache或者persist之后赋值给一个变量，下次直接使用这个变量就是使用的持久化的数据，当然，这里也可以直接对RDD进行cache 或者persist,下次直接使用RDD就可以
    3.如果对RDD进行持久化之后，赋值给了一个变量，那么不要在后面紧跟action算子
  • checkpoint执行流程
  • 1.当job执行完成之后，Spark会从后往前回溯，找到checkpointRDD进行标记
  • 2.回溯完成之后，Spark会启动一个job,对CheckpointRDD进行计算，将计算的结果保存在磁盘上
  • 优化：对哪个RDD进行checkpoint之前最好先cache()下

9.代码：

使用sample抽样找出出现次数最多的单词，过滤掉统计剩余单词的个数，并由大到小排序。

object Demo {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("test")
    val sc = new SparkContext(conf)
    val lines: RDD[String] = sc.textFile("./data/words")
    val words = lines.flatMap(line=>{line.split(" ")})
    val sortBy: RDD[(String, Int)] = words.sample(false,0.7).map(word=>{(word,1)}).reduceByKey(_+_).sortBy(_._2,false)
    val topWords = sortBy.map(tp=>{tp._1}).first()
    println(s"topWords is $topWords ")

    words.filter(word=>{!word.equals(topWords)}).map((_,1)).reduceByKey(_+_).sortBy(_._2,false).foreach(println)

  }
}