spark RDD编程 第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 rdd1 = data.filter(_.trim().length > 0)
    //第二步：执行map操作，取出RDD中每个元素，去除尾部空格并转换成整数，生成一个(key, value)键值对。
    val rdd2 = rdd1.map(line => (line.trim.toInt, ""))
    //第三步：对RDD进行重新分区，变成一个分区，
    //在分布式环境下只有把所有分区合并成一个分区，才能让所有元素排序后总体有序。
    val rdd3 = rdd2.partitionBy(new HashPartitioner(1))
    //第四步：执行sortByKey操作，对RDD中所有元素都按照key的升序排序。
    val rdd4 = rdd3.sortByKey()
    //第五步：执行keys操作，将键值对RDD中所有元素的key返回，形成一个新的RDD。
    val rdd5 = rdd4.keys
    //第六步：执行map操作，取出RDD中每个元素，生成一个(key, value)键值对，
    //其中key是整数的排序位次，value是原待排序的整数。
    var index = 0
    val rdd6 = rdd5.map(t => {
      index = index + 1
      (index, t)
    })
    //第七步：执行collect操作，以数组的形式返回RDD中所有元素。
    val rdd7 = rdd6.collect()
    //第八步：执行foreach操作，依次遍历数组中每个元素，分别取出(key, value)键值对中key和value，
    //按如下格式输出：key value
    println("") //注意：此行不要修改，否则会影响测试结果，在此行之后继续完成第八步的代码。
    rdd7.foreach(t => println(t._1 + " " + t._2))
    /********** End **********/
  }
}