Scala Spark DataFrame/Dataset为每种键高效方式找到最常见的值

问题： 我在映射spark中一个键的最常见值时遇到了一个问题（使用scala）。我已经用RDD完成了，但不知道如何有效地使用DF/DS（sparksql）

数据集类似于

key1 = value_a
key1 = value_b
key1 = value_b
key2 = value_a
key2 = value_c
key2 = value_c
key3 = value_a

火花转换和访问后，输出的每个键应具有其公共值

输出

key1 = valueb
key2 = valuec
key3 = valuea

一直尝试到现在：

RDD

我曾尝试在RDD中按

（键、值）组映射和减少，计数
，它产生了逻辑，但我无法将其转换为sparksql（数据帧/数据集）（因为我希望在网络上进行最小的随机移动）

这是我的RDD代码

 val data = List(

"key1,value_a",
"key1,value_b",
"key1,value_b",
"key2,value_a",
"key2,value_c",
"key2,value_c",
"key3,value_a"

)

val sparkConf = new SparkConf().setMaster("local").setAppName("example")
val sc = new SparkContext(sparkConf)

val lineRDD = sc.parallelize(data)

val pairedRDD = lineRDD.map { line =>
val fields = line.split(",")
(fields(0), fields(2))
}

val flatPairsRDD = pairedRDD.flatMap {
  (key, val) => ((key, val), 1)
}

val SumRDD = flatPairsRDD.reduceByKey((a, b) => a + b)




val resultsRDD = SumRDD.map{
  case ((key, val), count) => (key, (val,count))
 }.groupByKey.map{
  case (key, valList) => (name, valList.toList.sortBy(_._2).reverse.head)
}

resultsRDD.collect().foreach(println)

数据帧，使用窗口：我正在尝试使用
窗口。partitionBy（“key”，“value”）
来聚合窗口上的
计数。和thn
排序
和
agg（）
分别
根据我从你的问题中了解的情况，这里是你能做的

首先，您必须读取数据并将其转换为
dataframe

val df = sc.textFile("path to the data file")   //reading file line by line
  .map(line => line.split("="))                 // splitting each line by =
  .map(array => (array(0).trim, array(1).trim)) //tuple2(key, value) created
  .toDF("key", "value")                        //rdd converted to dataframe which required import sqlContext.implicits._

那是什么

+----+-------+
|key |value  |
+----+-------+
|key1|value_a|
|key1|value_b|
|key1|value_b|
|key2|value_a|
|key2|value_c|
|key2|value_c|
|key3|value_a|
+----+-------+

下一步是计算每个键相同值的重复次数，并选择每个键重复次数最多的值，可使用
窗口
功能和
聚合
，如下所示

import org.apache.spark.sql.expressions._                   //import Window library
def windowSpec = Window.partitionBy("key", "value")         //defining a window frame for the aggregation
import org.apache.spark.sql.functions._                     //importing inbuilt functions
df.withColumn("count", count("value").over(windowSpec))     // counting repeatition of value for each group of key, value and assigning that value to new column called as count
  .orderBy($"count".desc)                                   // order dataframe with count in descending order
  .groupBy("key")                                           // group by key
  .agg(first("value").as("value"))                          //taking the first row of each key with count column as the highest

因此，最终输出应等于

+----+-------+
|key |value  |
+----+-------+
|key3|value_a|
|key1|value_b|
|key2|value_c|
+----+-------+ 

使用
groupBy
怎么样

val maxFreq= udf((values: List[Int]) => {
  values.groupBy(identity).mapValues(_.size).maxBy(_._2)._1
})

df.groupBy("key")
  .agg(collect_list("value") as "valueList")
  .withColumn("mostFrequentValue", maxFreq(col("valueList")))

在按键分组、带计数的值、按计数排序并获得排名第一的行之后，需要使用窗口函数。你可以查看这个@eliasah谢谢，寻找它的错误链接！我已经更新了。我在打电话，所以我不能写一封信answer@eliasah没问题，请在您有可能的时候写感谢您的回答，我会尽可能地测试简短的指令。@RameshMaharjan谢谢您的回答。对于使用
groupBy
与
Window
函数相比的性能差异，您有何看法？