Spark算子综合案例

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

安得广厦千万间，大庇天下寒士俱欢颜。

---

一、第1关：WordCount - 词频统计

任务描述
本关任务：使用 Spark Core 知识编写一个词频统计程序。

编程要求
请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

对文本文件内的每个单词都统计出其出现的次数。
按照每个单词出现次数的数量，降序排序。
文本文件内容如下：

hello java
hello python java
hello python python
hello flink
scala scala scala scala scala
说明：单词与单词之间以空格进行分割

测试说明
补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。
测试输入：可查看右侧文件夹中wordcount.txt文件，具体内容为上述文本内容。
预期输出：
(scala,5)
(hello,4)
(python,3)
(java,2)
(flink,1)

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object WordCount {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local").setAppName("WordCount")
    val sc = new SparkContext(conf)
    val path = "file:///root/files/wordcount.txt"
    /********* Begin *********/

    
    //读取文件创建RDD
    val lines=sc.textFile("file:///root/files/wordcount.txt")
    //切分并压平
    val words=lines.flatMap(line=>line.split(" "))

    //组装
    val wordAndOne=words.map(word=>(word,1))
    //分组聚合
    val wordCount=wordAndOne.reduceByKey((a,b)=>a+b)
    //排序
    
    val result: RDD[(String, Int)] = wordCount.sortBy(_._2, false)

    //输出
    result.foreach(println)
	/********* End *********/

    sc.stop()
  }

}

二、第2关：friend recommendation - 好友推荐

任务描述
本关任务：使用 Spark Core 知识完成 " 好友推荐 " 的程序。

相关知识
直接好友与间接好友
参照数据如下：

hello hadoop cat
world hadoop hello hive
cat tom hive
…
…
数据说明（第二行为例）：
这个人叫 world ，他有三个好友，分别是：hadoop、hello 和 hive。hadoop、hello 和 hive 之间就是间接好友。word 与 hadoop 、 hello 、hive 属于直接好友。

编程要求
请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，完成统计间接好友的数量的程序。

统计间接好友的参照数据如下：

(world_tom,2)
(tom_mr,1)
(mr_hadoop,1)
…
…
参考数据说明：以 (world_tom,2) 为例，用户 world 与用户 tom 在间接好友关系中出现的次数为 2。

特别说明：(world_tom,2) 与 (tom_world,2) 属于同一数据，请使用 hashcode 来排列用户 world 与 用户 tom 的前后顺序。

测试说明
补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。

预期结果：

(world_tom,2)
(tom_mr,1)
(mr_hadoop,1)
(cat_mr,1)
(world_cat,1)
(cat_hadoop,2)
(hive_tom,3)
(world_mr,2)
代码如下（示例）：

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Friend {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local").setAppName("friend")
    val sc = new SparkContext(conf)
    val path = "file:///root/files/friend.txt"
	/********* Begin *********/

    //1.创建RDD
    val rdd: RDD[String] = sc.textFile(path)

    //2.切分压平
   val rdd1: RDD[(String, Int)] = rdd.flatMap(line => {  
      //2.1创建可变集合
       var a = List[(String, Int)]() 
      //2.2切分
      val split = line.split(" ")
      //2.3取出第一个我
      val me=split(0)
      //2.4遍历
     for (i <- 1 until split.length) { 
      //2.4.1将我的直接好友拼接加入集合并将次数设为0（拼接时可以按hashcode值大的放前面）
  

        val s = if (me.hashCode > split(i).hashCode) me + "_" + split(i) else split(i) + "_" + me  

        a ::= (s, 0)  

       
      //2.4.2遍历
      for (j <- i+1 until split.length) { 
      //2.4.2.1将间接好友拼接加入集合将此数设为1
       val ss = if (split(j).hashCode > split(i).hashCode) split(j) + "_" + split(i) else split(i) + "_" + split(j)  

          a ::= (ss, 1)

        }  

      }  
      //2.5返回集合
          a  

    })  
    //3分组
     val rdd2: RDD[(String, Iterable[Int])] = rdd1.groupByKey()  
    //4判断每一行里如果为直接好友将其次数设为0，如果不是+1
       val rdd3: RDD[(String, Int)] = rdd2.map(x => {

      var bool = false  

      var count = 0  

      val flags = x._2  

      val name = x._1  

      for (flag <- flags) {  

        if (flag == 0) bool = true  

        count += 1  

      }  

      if (bool == false) (name, count)  

      else ("直接好友", 0)  

    })  

    //5过滤掉次数为0的剩下的就是间接好友及其次数
     val tu: RDD[(String, Int)] = rdd3.filter((x) => if (x._2 !=0) true else false)  
    //6输出

tu.foreach(println) 
	/********* End *********/

    sc.stop()

  }
}

---

总结

wordCount.sortBy(_._2, false)对聚合之后的值进行降序排序。