Java Spark 2.2.0 API：我应该选择使用Groupby与aggregate相结合的Dataset，还是使用ReduceBykey的RDD

大家好，首先，根据标题，有人可能会说这个问题已经得到了回答，但我的观点是比较ReduceBykey、GroupBykey性能、特定于Dataset和RDDAPI。我在许多帖子中看到，ReduceBykey方法的性能比GroupByKey更有效，当然我同意这一点。然而，我有点困惑，如果我们使用数据集或RDD，我无法理解这些方法的行为。每种情况下应该使用哪一种

我将尝试更具体，因此我将提供我的问题与我的解决方案，以及与工作代码，我期待在您最早的方便，建议我在这方面的改进

+---+------------------+-----+
|id |Text1             |Text2|
+---+------------------+-----+
|1  |one,two,three     |one  |
|2  |four,one,five     |six  |
|3  |seven,nine,one,two|eight|
|4  |two,three,five    |five |
|5  |six,five,one      |seven|
+---+------------------+-----+

这里的要点是检查第三列是否包含在第二列的每一行上，然后收集它们的所有ID。例如，第三列的单词“one”出现在第二列的句子中，ID为1、5、2、3

+-----+------------+
|Text2|Set         |
+-----+------------+
|seven|[3]         |
|one  |[1, 5, 2, 3]|
|six  |[5]         |
|five |[5, 2, 4]   |
+-----+------------+

这是我的工作代码

List<Row> data = Arrays.asList(
                RowFactory.create(1, "one,two,three", "one"),
                RowFactory.create(2, "four,one,five", "six"),
                RowFactory.create(3, "seven,nine,one,two", "eight"),
                RowFactory.create(4, "two,three,five", "five"),
                RowFactory.create(5, "six,five,one", "seven")
        );

        StructType schema = new StructType(new StructField[]{
                new StructField("id", DataTypes.IntegerType, false, Metadata.empty()),
                new StructField("Text1", DataTypes.StringType, false, Metadata.empty()),
                new StructField("Text2", DataTypes.StringType, false, Metadata.empty())
        });

        Dataset<Row> df = spark.createDataFrame(data, schema);
        df.show(false);
        Dataset<Row> df1 = df.select("id", "Text1")
                .crossJoin(df.select("Text2"))
                .filter(col("Text1").contains(col("Text2")))
                .orderBy(col("Text2"));

        df1.show(false);

        Dataset<Row> df2 = df1
                .groupBy("Text2")
                .agg(collect_set(col("id")).as("Set"));

        df2.show(false);

List data=Arrays.asList(
创建（1，“一，二，三”，“一”），
创建（2，“四，一，五”，“六”），
创建（3，“七，九，一，二”，“八”），
创建（4，“二，三，五”，“五”），
创建（5，“六，五，一”，“七”）
);
StructType架构=新StructType（新StructField[]{
新建StructField（“id”，DataTypes.IntegerType，false，Metadata.empty（）），
新建StructField（“Text1”，DataTypes.StringType，false，Metadata.empty（）），
新建StructField（“Text2”，DataTypes.StringType，false，Metadata.empty（））
});
数据集df=spark.createDataFrame（数据，模式）；
df.show（假）；
数据集df1=df.select（“id”，“Text1”）
.crossJoin（df.select（“Text2”））
.filter（列（“Text1”）。包含（列（“Text2”））
.orderBy（col（“Text2”）；
df1.显示（假）；
数据集df2=df1
.groupBy（“Text2”）
.agg（col_set（col（“id”））.as（“set”）；
df2.显示（假）；

我的问题分为三个部分：

• 为了提高性能，我是否需要在RDD中转换数据集并使用ReduceBykey而不是Dataset groupby
• 我应该使用哪一个？为什么？数据集或RDD
• 如果我的方法中存在其他更有效的解决方案，我将不胜感激

---

TL；DR两者都不好，但如果您使用的是

Dataset

请继续使用

Dataset

Dataset.groupBy

如果与适当的函数一起使用，其行为类似于

reduceByKey

。不幸的是，

collect\u set

的行为非常类似于

groupByKey

，前提是重复的数量很少。用

reduceByKey

重写它
如果我的方法中存在其他更有效的解决方案，我将不胜感激
您所能做的最好的事情就是删除

交叉连接

：

val df = Seq((1, "one,two,three", "one"),
  (2, "four,one,five", "six"),
  (3, "seven,nine,one,two", "eight"),
  (4, "two,three,five", "five"),
  (5, "six,five,one", "seven")).toDF("id", "text1", "text2")

df.select(col("id"), explode(split(col("Text1"), ",")).alias("w"))
  .join(df.select(col("Text2").alias("w")), Seq("w"))
  .groupBy("w")
  .agg(collect_set(col("id")).as("Set")).show

+-----+------------+
|    w|         Set|
+-----+------------+
|seven|         [3]|
|  one|[1, 5, 2, 3]|
|  six|         [5]|
| five|   [5, 2, 4]|
+-----+------------+