第1关：数据去重
任务描述
本关任务：编写Spark独立应用程序实现数据去重。
相关知识
为了完成本关任务，你需要掌握：RDD的创建；RDD的转换操作；RDD的行动操作。
RDD的创建
使用textFile()方法从本地文件系统中加载数据创建RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
执行sc.textFile()方法以后，Spark从本地文件word.txt中加载数据到内存，在内存中生成一个RDD对象lines，这个RDD里面包含了若干个元素，每个元素的类型是String类型，也就是说，从word.txt文件中读取出来的每一行文本内容，都成为RDD中的一个元素。
使用map()函数转换得到相应的键值对RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
val pairRDD = lines.flatMap(line => line.split(" ")).map(word => (word,1))
上面示例中，map(word=>(word,1))函数的作用是取出RDD中的每个元素，也就是每个单词，赋值给word，然后把word转换成 (word,1) 的键值对形式。
RDD的转换操作
对于RDD而言，每一次转换操作都会产生新的RDD，供给下一个操作使用。RDD的转换过程是惰性求值的，也就是说，整个转换过程只是记录了转换的轨迹，并不会发生真正的计算，只有遇到行动操作时，才会触发真正的计算。常见的RDD转换操作如下所示：
filter(func)：筛选出满足函数func的元素，并返回一个新的RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
val linesWithSpark = lines.filter(line => line.contains(“Spark”))
map(func)：将每个元素传递到函数func中，并将结果返回为一个新的RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
val words = lines.map(line => line.split(" "))
groupByKey()：应用于(K,V)键值对RDD时，返回一个新的(K, Iterable)形式的RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
val words = lines.flatMap(line => line.split(" ")).map(word => (word,1)).groupByKey()
sortByKey()：应用于(K,V)键值对RDD时，返回一个新的根据key排序的RDD，示例如下：
val pairRDD = sc.parallelize(Array(“Hadoop”,3),(“Spark”,5),(“Hive”,2))
pairRDD.sortByKey().foreach(println)
输出：
(Hadoop,3)
(Hive,2)
(Spark,5)
partitionBy(partitioner: Partitioner)：根据partitioner函数生成新的ShuffleRDD，将原RDD重新分区，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”, 3)
val words = lines.flatMap(line => line.split(" ")).map(word => (word,1)).partitionBy(new HashPartitioner(1))
keys：将键值对RDD中所有元素的key返回，形成一个新的RDD，示例如下：
val pairRDD = sc.parallelize(Array(“Hadoop”,3),(“Spark”,5),(“Hive”,2))
pairRDD.keys.foreach(println)
输出：
Hadoop
Spark
Hive
RDD的行动操作
对于RDD而言，只有遇到行动操作时才会执行“从头到尾”的真正的计算，从文件中加载数据，完成一次又一次转换操作，最终，完成行动操作得到结果。常见的RDD行动操作如下所示：
count()：返回RDD中元素的个数
collect()：以数组的形式返回RDD中的所有元素
first()：返回RDD中的第一个元素
take(n)：以数组的形式返回RDD中的前n个元素
reduce(func)：通过函数func(输入两个参数并返回一个值)聚合RDD中的元素
foreach(func)：将RDD中的每个元素传递到函数func中运行 下面通过一个示例来介绍上述行动操作，如下所示：
val rdd = sc.parallelize(Array(1,2,3,4,5))
println(rdd.count)
println(rdd.first)
println(rdd.take(3).mkString(", “))
println(rdd.collect().mkString(”-> "))
rdd.foreach(println)
输出： 5 1 1, 2, 3 1-> 2-> 3-> 4-> 5 1 2 3 4 5
编程要求
对于两个输入文件A和B，编写Spark独立应用程序，对两个文件进行合并、剔除其中重复的内容并排序，得到一个新文件C。下面是输入文件和输出文件的一个样例，供参考。
输入文件A的样例如下：
20170101 x
20170102 y
20170103 x
20170104 y
20170105 z
20170106 z
输入文件B的样例如下：
20170101 y
20170102 y
20170103 x
20170104 z
20170105 y
输出文件C的样例如下：
20170101 x
20170101 y
20170102 y
20170103 x
20170104 y
20170104 z
20170105 y
20170105 z
20170106 z
测试说明
本实训目前是基于Spark单机模式的运行方式，完成整个评测流程所需时间较长（全过程耗时约60秒），请耐心等待!
开始你的任务吧，祝你成功！
代码如下：
import org.apache.spark.SparkContext
import org.apache.spark.SparkConf
import org.apache.spark.HashPartitioner
object RemDup {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("RemDup").setMaster("local")
val sc = new SparkContext(conf)
//输入文件fileA.txt和fileB.txt已保存在本地文件系统/root/step1_files目录中
val dataFile = "file:///root/step1_files"
val data = sc.textFile(dataFile, 2)
/********** Begin **********/
//第一步：执行过滤操作，把空行丢弃。
val rdd_1 = data.filter(_.trim().length > 0)
//第二步：执行map操作，取出RDD中每个元素，去除尾部空格并生成一个(key, value)键值对。
val rdd_2 = rdd_1.map(line => (line.trim, ""))
//第三步：执行groupByKey操作，把所有key相同的value都组织成一个value-list。
val rdd_3 = rdd_2.groupByKey()
//第四步：对RDD进行重新分区，变成一个分区，
//在分布式环境下只有把所有分区合并成一个分区，才能让所有元素排序后总体有序。
val rdd_4 = rdd_3.partitionBy(new HashPartitioner(1))
//第五步：执行sortByKey操作，对RDD中所有元素都按照key的升序排序。
val rdd_5 = rdd_4.sortByKey()
//第六步：执行keys操作，将键值对RDD中所有元素的key返回，形成一个新的RDD。
val rdd_6 = rdd_5.keys
//第七步：执行collect操作，以数组的形式返回RDD中所有元素。
val rdd_7 = rdd_6.collect()
//第八步：执行foreach操作，并使用println打印出数组中每个元素的值。
println("") //注意：此行不要修改，否则会影响测试结果，在此行之后继续完成第八步的代码。
rdd_7.foreach(println)
/********** End **********/
}
}
第2关：整合排序
任务描述
本关任务：编写Spark独立应用程序实现整合排序。
相关知识
为了完成本关任务，你需要掌握：RDD的创建；RDD的转换操作；RDD的行动操作。
RDD的创建
使用textFile()方法从本地文件系统中加载数据创建RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
执行sc.textFile()方法以后，Spark从本地文件word.txt中加载数据到内存，在内存中生成一个RDD对象lines，这个RDD里面包含了若干个元素，每个元素的类型是String类型，也就是说，从word.txt文件中读取出来的每一行文本内容，都成为RDD中的一个元素。
使用map()函数转换得到相应的键值对RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
val pairRDD = lines.flatMap(line => line.split(" ")).map(word => (word,1))
上面示例中，map(word=>(word,1))函数的作用是取出RDD中的每个元素，也就是每个单词，赋值给word，然后把word转换成(word,1)的键值对形式。
RDD的转换操作
对于RDD而言，每一次转换操作都会产生新的RDD，供给下一个操作使用。RDD的转换过程是惰性求值的，也就是说，整个转换过程只是记录了转换的轨迹，并不会发生真正的计算，只有遇到行动操作时，才会触发真正的计算。常见的RDD转换操作如下所示：
filter(func)：筛选出满足函数func的元素，并返回一个新的RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
val linesWithSpark = lines.filter(line => line.contains(“Spark”))
map(func)：将每个元素传递到函数func中，并将结果返回为一个新的RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
val words = lines.map(line => line.split(" "))
sortByKey()：应用于(K,V)键值对RDD时，返回一个新的根据key排序的RDD，示例如下：
val pairRDD = sc.parallelize(Array(“Hadoop”,3),(“Spark”,5),(“Hive”,2))
pairRDD.sortByKey().foreach(println)
输出：
(Hadoop,3)
(Hive,2)
(Spark,5)
partitionBy(partitioner: Partitioner)：根据partitioner函数生成新的ShuffleRDD，将原RDD重新分区，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”, 3)
val words = lines.flatMap(line => line.split(" ")).map(word => (word,1)).partitionBy(new HashPartitioner(1))
keys：将键值对RDD中所有元素的key返回，形成一个新的RDD，示例如下：
val pairRDD = sc.parallelize(Array(“Hadoop”,3),(“Spark”,5),(“Hive”,2))
pairRDD.keys.foreach(println)
输出：
Hadoop
Spark
Hive
RDD的行动操作
对于RDD而言，只有遇到行动操作时才会执行“从头到尾”的真正的计算，从文件中加载数据，完成一次又一次转换操作，最终，完成行动操作得到结果。常见的RDD行动操作如下所示：
count()：返回RDD中元素的个数
collect()：以数组的形式返回RDD中的所有元素
first()：返回RDD中的第一个元素
take(n)：以数组的形式返回RDD中的前n个元素
reduce(func)：通过函数func(输入两个参数并返回一个值)聚合RDD中的元素
foreach(func)：将RDD中的每个元素传递到函数func中运行 下面通过一个示例来介绍上述行动操作，如下所示：
val rdd = sc.parallelize(Array(1,2,3,4,5))
println(rdd.count)
println(rdd.first)
println(rdd.take(3).mkString(", “))
println(rdd.collect().mkString(”-> "))
rdd.foreach(println)
输出： 5 1 1, 2, 3 1-> 2-> 3-> 4-> 5 1 2 3 4 5
编程要求
假设某个目录下有多个文本文件，每个文件中每一行内容均为一个整数。要求读取所有文件中的整数，进行排序后，输出到一个新的文件中，输出的内容为每行两个整数，第一个整数为第二个整数的排序位次，第二个整数为原待排序的整数。下面是输入文件和输出文件的一个样例，供参考。
输入文件1的样例如下：
33
37
12
40
输入文件2的样例如下：
4
16
39
5
输入文件3的样例如下：
1
45
25
输出文件的样例如下：
1 1
2 4
3 5
4 12
5 16
6 25
7 33
8 37
9 39
10 40
11 45
测试说明
本实训目前是基于Spark单机模式的运行方式，完成整个评测流程所需时间较长（全过程耗时约60秒），请耐心等待!
开始你的任务吧，祝你成功！
代码如下：
import org.apache.spark.SparkContext
import org.apache.spark.SparkConf
import org.apache.spark.HashPartitioner
object FileSort {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("FileSort").setMaster("local")
val sc = new SparkContext(conf)
//输入文件file1.txt、file2.txt和file3.txt已保存在本地文件系统/root/step2_files目录中
val dataFile = "file:///root/step2_files"
val data = sc.textFile(dataFile, 3)
/********** Begin **********/
//第一步：执行过滤操作，把空行丢弃。
val rdd_1 = data.filter(_.trim().length > 0)
//第二步：执行map操作，取出RDD中每个元素，去除尾部空格并转换成整数，生成一个(key, value)键值对。
val rdd_2 = rdd_1.map(line => (line.trim.toInt, ""))
//第三步：对RDD进行重新分区，变成一个分区，
//在分布式环境下只有把所有分区合并成一个分区，才能让所有元素排序后总体有序。
val rdd_3 = rdd_2.partitionBy(new HashPartitioner(1))
//第四步：执行sortByKey操作，对RDD中所有元素都按照key的升序排序。
val rdd_4 = rdd_3.sortByKey()
//第五步：执行keys操作，将键值对RDD中所有元素的key返回，形成一个新的RDD。
val rdd_5 = rdd_4.keys
//第六步：执行map操作，取出RDD中每个元素，生成一个(key, value)键值对，
//其中key是整数的排序位次，value是原待排序的整数。
var index = 0
val rdd_6 = rdd_5.map(t => {
index = index + 1
(index, t)
})
//第七步：执行collect操作，以数组的形式返回RDD中所有元素。
val rdd_7 = rdd_6.collect()
//第八步：执行foreach操作，依次遍历数组中每个元素，分别取出(key, value)键值对中key和value，
//按如下格式输出：key value
println("") //注意：此行不要修改，否则会影响测试结果，在此行之后继续完成第八步的代码。
rdd_7.foreach(t => println(t._1 + " " + t._2))
/********** End **********/
}
}
第3关：求平均值
任务描述
本关任务：编写Spark独立应用程序实现求平均值。
相关知识
为了完成本关任务，你需要掌握：RDD的创建；RDD的转换操作；RDD的行动操作。
RDD的创建
使用textFile()方法从本地文件系统中加载数据创建RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
执行sc.textFile()方法以后，Spark从本地文件word.txt中加载数据到内存，在内存中生成一个RDD对象lines，这个RDD里面包含了若干个元素，每个元素的类型是String类型，也就是说，从word.txt文件中读取出来的每一行文本内容，都成为RDD中的一个元素。
使用map()函数转换得到相应的键值对RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
val pairRDD = lines.flatMap(line => line.split(" ")).map(word => (word,1))
上面示例中，map(word=>(word,1))函数的作用是取出RDD中的每个元素，也就是每个单词，赋值给word，然后把word转换成(word,1)的键值对形式。
RDD的转换操作
对于RDD而言，每一次转换操作都会产生新的RDD，供给下一个操作使用。RDD的转换过程是惰性求值的，也就是说，整个转换过程只是记录了转换的轨迹，并不会发生真正的计算，只有遇到行动操作时，才会触发真正的计算。常见的RDD转换操作如下所示：
filter(func)：筛选出满足函数func的元素，并返回一个新的RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
val linesWithSpark = lines.filter(line => line.contains(“Spark”))
map(func)：将每个元素传递到函数func中，并将结果返回为一个新的RDD，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
val words = lines.map(line => line.split(" “))
reduceByKey(func)：应用于(K,V)键值对RDD时，返回一个新的(K, V)形式的RDD，其中每个值是将每个key传递到函数func中进行聚合后的结果，示例如下：
val lines = sc.textFile(“file:///home/hadoop/word.txt”)
val words = lines.flatMap(line => line.split(” ")).map(word => (word,1)).reduceByKey(+)
mapValues(func)：对键值对RDD中的每个value都应用一个函数，但是key不会发生变化，示例如下：
val pairRDD = sc.parallelize(Array(“Hadoop”,3),(“Spark”,5),(“Hive”,2))
pairRDD.mapValues(x => x+1).foreach(println)
输出： (Hadoop,4) (Spark,6) (Hive,3)
RDD的行动操作
对于RDD而言，只有遇到行动操作时才会执行“从头到尾”的真正的计算，从文件中加载数据，完成一次又一次转换操作，最终，完成行动操作得到结果。常见的RDD行动操作如下所示：
count()：返回RDD中元素的个数
collect()：以数组的形式返回RDD中的所有元素
first()：返回RDD中的第一个元素
take(n)：以数组的形式返回RDD中的前n个元素
reduce(func)：通过函数func(输入两个参数并返回一个值)聚合RDD中的元素
foreach(func)：将RDD中的每个元素传递到函数func中运行 下面通过一个示例来介绍上述行动操作，如下所示：
val rdd = sc.parallelize(Array(1,2,3,4,5))
println(rdd.count)
println(rdd.first)
println(rdd.take(3).mkString(", “))
println(rdd.collect().mkString(”-> "))
rdd.foreach(println)
输出： 5 1 1, 2, 3 1-> 2-> 3-> 4-> 5 1 2 3 4 5
计算图书平均销量的示例
给定一组键值对(“Spark”,2)、(“Hadoop”,6)、(“Hadoop”,4)、(“Spark”,6)，键值对的key表示图书名称，value表示某天图书销量，现在需要计算每个键对应的平均值，也就是计算每种图书的平均销量，如下所示：
val rdd = sc.parallelize(Array((“Spark”,2),(“Hadoop”,6),(“Hadoop”,4),(“Spark”,6)))
val rdd1 = rdd.mapValues(x => (x, 1))
val rdd2 = rdd1.reduceByKey((x, y) => (x._1 + y._1, x._2 + y._2))
val rdd3 = rdd2.mapValues(x => (x._1 / x._2))
rdd3.foreach(println)
输出：
(Spark,4)
(Hadoop,5)
计算图书平均销量过程示意图
####编程要求 每个输入文件表示学生某门课程的成绩，输入文件中每行内容由两个字段组成，第一个字段是学生姓名，第二个字段是学生的成绩；编写Spark独立应用程序求出所有学生的平均成绩，并输出到一个新文件中。下面是输入文件和输出文件的一个样例，供参考。 输入文件(AlgorithmScore)的样例如下： XiaoMing 92 XiaoHong 87 XiaoXin 82 XiaoLi 90 输入文件(DataBaseScore)的样例如下： XiaoMing 95 XiaoHong 81 XiaoXin 89 XiaoLi 85 输入文件(PythonScore)的样例如下： XiaoMing 82 XiaoHong 83 XiaoXin 94 XiaoLi 91 输出文件的样例如下： XiaoMing 89.67 XiaoXin 88.33 XiaoHong 83.67 XiaoLi 88.67
测试说明
本实训目前是基于Spark单机模式的运行方式，完成整个评测流程所需时间较长（全过程耗时约60秒），请耐心等待!
开始你的任务吧，祝你成功！
代码如下：
import org.apache.spark.SparkContext
import org.apache.spark.SparkConf
object AvgScore {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("AvgScore").setMaster("local")
val sc = new SparkContext(conf)
//输入文件AlgorithmScore.txt、DataBaseScore.txt和PythonScore.txt已保存在本地文件系统/root/step3_files目录中
val dataFile = "file:///root/step3_files"
val data = sc.textFile(dataFile)
/********** Begin **********/
//第一步：执行过滤操作，把空行丢弃。
val rdd_1 = data.filter(_.trim().length > 0)
//第二步：执行map操作，取出RDD中每个元素(即一行文本)，以空格作为分隔符将一行文本拆分成两个字符串，
//拆分后得到的字符串封装在一个数组对象中，成为新的RDD中一个元素。
var rdd_2 = rdd_1.map(line => line.split(" "))
//第三步：执行map操作，取出RDD中每个元素(即字符串数组)，取字符串数组中第一个元素去除尾部空格，
//取字符串数组中第二个元素去除尾部空格并转换成整数，并由这两部分构建一个(key, value)键值对。
val rdd_3 = rdd_2.map(t => (t(0).trim, t(1).trim.toInt))
//第四步：执行mapValues操作，取出键值对RDD中每个元素的value，使用x=>(x,1)这个匿名函数进行转换。
val rdd_4 = rdd_3.mapValues(x => (x, 1))
//第五步：执行reduceByKey操作，计算出每个学生所有课程的总分数和总课程门数。
val rdd_5 = rdd_4.reduceByKey((x, y) => (x._1 + y._1, x._2 + y._2))
//第六步：执行mapValues操作，计算出每个学生的平均成绩。
val rdd_6 = rdd_5.mapValues(x => (x._1.toDouble / x._2))
//第七步：执行collect操作，以数组的形式返回RDD中所有元素。
val rdd_7 = rdd_6.collect()
//第八步：执行foreach操作，按如下格式打印出每个学生的平均成绩：姓名 成绩，其中成绩要求保留两位小数。
println("") //注意：此行不要修改，否则会影响测试结果，在此行之后继续完成第八步的代码。
rdd_7.foreach(t => {
val abc = t._2
println(t._1 + " " + f"$abc%1.2f")
})
/********** End **********/
}
}
2067
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
