出5道关于Spark RDD相关的几道程序设计题并给出答案

统计一个文本文件中每个单词出现的次数，并按照出现次数从大到小排序输出前10个单词及其出现次数。

val textFile = sc.textFile("file.txt")
val wordCounts = textFile.flatMap(line => line.split(" "))
                         .map(word => (word, 1))
                         .reduceByKey(_ + _)
                         .map(item => (item._2, item._1))
                         .sortByKey(false)
                         .take(10)
wordCounts.foreach(item => println(item._2 + ": " + item._1))

统计一个文本文件中每个单词的长度，并将长度为偶数的单词按照字典序排序输出。

val textFile = sc.textFile("file.txt")
val wordLengths = textFile.flatMap(line => line.split(" "))
                          .map(word => (word.length, word))
                          .filter(item => item._1 % 2 == 0)
                          .sortBy(item => item._2)
                          .values
wordLengths.foreach(println)

统计一个文本文件中每个单词的长度，并将长度为奇数的单词按照出现次数从多到少排序输出。

val textFile = sc.textFile("file.txt")
val wordCounts = textFile.flatMap(line => line.split(" "))
                         .map(word => (word.length, 1))
                         .filter(item => item._1 % 2 == 1)
                         .reduceByKey(_ + _)
                         .map(item => (item._2, item._1))
                         .sortByKey(false)
                         .map(item => (item._2, item._1))
wordCounts.foreach(item => println(item._1 + ": " + item._2))

统计一个文本文件中每个单词的长度，并将长度为偶数的单词按照出现次数从少到多排序输出。

val textFile = sc.textFile("file.txt")
val wordCounts = textFile.flatMap(line => line.split(" "))
                         .map(word => (word.length, 1))
                         .filter(item => item._1 % 2 == 0)
                         .reduceByKey(_ + _)
                         .map(item => (item._2, item._1))
                         .sortByKey()
                         .map(item => (item._2, item._1))
wordCounts.foreach(item => println(item._1 + ": " + item._2))

统计一个文本文件中每个单词的长度，并将长度为奇数的单词按照长度从大到小排序输出。

val textFile = sc.textFile("file.txt")
val wordLengths = textFile.flatMap(line => line.split(" "))
                          .filter(word => word.length % 2 == 1)
                          .sortBy(word => -word.length)
wordLengths.foreach(println)
``