Java Apache Spark flatMaps&；数据争用

我必须将数据透视到一个文件中，然后将其存储到另一个文件中。我在旋转数据时遇到了一些困难

我有多个文件，其中包含的数据看起来有点像我下面展示的。列的长度是可变的。首先，我正在尝试合并这些文件。但由于某些原因，输出不正确。我甚至没有尝试过pivot方法，但也不知道如何使用它

如何做到这一点

File 1:
0,26,27,30,120
201008,100,1000,10,400
201009,200,2000,20,500
201010,300,3000,30,600

File 2:
0,26,27,30,120,145
201008,100,1000,10,400,200
201009,200,2000,20,500,100
201010,300,3000,30,600,150

File 3:
0,26,27,120,145
201008,100,10,400,200
201009,200,20,500,100
201010,300,30,600,150

Output:
201008,26,100
201008,27,1000
201008,30,10
201008,120,400
201008,145,200
201009,26,200
201009,27,2000
201009,30,20
201009,120,500
201009,145,100
.....

我不太熟悉Spark，但我正在尝试使用flatMap和flatMapValues。我不知道我现在如何使用它，但希望得到一些指导

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.VoidFunction;
import org.apache.spark.sql.SparkSession;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ExecutionTest {
    public static void main(String[] args) {
        Logger.getLogger("org.apache").setLevel(Level.WARN);
        Logger.getLogger("org.spark_project").setLevel(Level.WARN);
        Logger.getLogger("io.netty").setLevel(Level.WARN);
        log.info("Starting...");
        // Step 1: Create a SparkContext.
        boolean isRunLocally = Boolean.valueOf(args[0]);
        String filePath = args[1];

        SparkConf conf = new SparkConf().setAppName("Variable File").set("serializer",
                "org.apache.spark.serializer.KryoSerializer");
        if (isRunLocally) {
            log.info("System is running in local mode");
            conf.setMaster("local[*]").set("spark.executor.memory", "2g");
        }

        SparkSession session = SparkSession.builder().config(conf).getOrCreate();

        JavaSparkContext jsc = new JavaSparkContext(session.sparkContext());
        jsc.textFile(filePath, 2)
           .map(new Function<String, String[]>() {
                private static final long serialVersionUID = 1L;
                @Override
                public String[] call(String v1) throws Exception {
                    return StringUtils.split(v1, ",");
                }                       
            })
            .foreach(new VoidFunction<String[]>() {
                private static final long serialVersionUID = 1L;
                @Override
                public void call(String[] t) throws Exception {
                    for (String string : t) {
                        log.info(string);
                    }   
                }

            });     
    }

}

导入org.apache.commons.lang.StringUtils；
导入org.apache.log4j.Level；
导入org.apache.log4j.Logger；
导入org.apache.spark.SparkConf；
导入org.apache.spark.api.java.JavaRDD；
导入org.apache.spark.api.java.JavaSparkContext；
导入org.apache.spark.api.java.function.function；
导入org.apache.spark.api.java.function.VoidFunction；
导入org.apache.spark.sql.SparkSession；
导入lombok.extern.slf4j.slf4j；
@Slf4j
公共类执行测试{
公共静态void main（字符串[]args）{
Logger.getLogger（“org.apache”）.setLevel（Level.WARN）；
Logger.getLogger（“org.spark_项目”）.setLevel（Level.WARN）；
Logger.getLogger（“io.netty”）.setLevel（Level.WARN）；
log.info（“开始…”）；
//步骤1：创建SparkContext。
boolean isrunlocy=boolean.valueOf（args[0]）；
字符串filePath=args[1]；
SparkConf conf=new SparkConf（）.setAppName（“变量文件”）.set（“序列化程序”，
“org.apache.spark.serializer.KryoSerializer”）；
如果（非法）{
log.info（“系统在本地模式下运行”）；
conf.setMaster（“local[*]）.set（“spark.executor.memory”，“2g”）；
}
SparkSession session=SparkSession.builder（）.config（conf.getOrCreate（）；
JavaSparkContext jsc=新的JavaSparkContext（session.sparkContext（））；
textFile（文件路径，2）
.map（新函数（）{
私有静态最终长serialVersionUID=1L；
@凌驾
公共字符串[]调用（字符串v1）引发异常{
返回StringUtils.split（v1，“，”）；
}                       
})
.foreach（新的VoidFunction（）{
私有静态最终长serialVersionUID=1L；
@凌驾
公共void调用（字符串[]t）引发异常{
for（字符串：t）{
log.info（字符串）；
}   
}
});     
}
}

Scala中的解决方案由于我不是JAVA人，您应该能够适应。并添加排序、缓存等

数据如下，3个文件的重复条目明显，如果你不想摆脱它

      0, 5,10, 15  20
 202008, 5,10, 15, 20
 202009,10,20,100,200

上面生成了8行

      0,888,999
 202008,  5, 10
 202009, 10, 20

     0, 5
202009,10

上面生成了4行

      0,888,999
 202008,  5, 10
 202009, 10, 20

     0, 5
202009,10

1行，这是重复的

// Bit lazy with columns names, but anyway.

import org.apache.spark.sql.functions.input_file_name  
import org.apache.spark.sql.expressions.Window
import org.apache.spark.sql.functions._ 
import spark.implicits._

val inputPath: String = "/FileStore/tables/g*.txt"  
val rdd = spark.read.text(inputPath)
  .select(input_file_name, $"value")   
  .as[(String, String)] 
  .rdd

val rdd2 = rdd.zipWithIndex
val rdd3 = rdd2.map(x => (x._1._1, x._2, x._1._2.split(",").toList.map(_.toInt)))  
val rdd4 = rdd3.map { case (pfx, pfx2, list) => (pfx,pfx2,list.zipWithIndex) }
val df = rdd4.toDF()
df.show(false)
df.printSchema()

val df2 = df.withColumn("rankF", row_number().over(Window.partitionBy($"_1").orderBy($"_2".asc)))
df2.show(false)
df2.printSchema()

val df3 = df2.withColumn("elements", explode($"_3"))
df3.show(false)
df3.printSchema()

val df4 = df3.select($"_1", $"rankF", $"elements".getField("_1"), $"elements".getField("_2")).toDF("fn", "line_num", "val", "col_pos")
df4.show(false)
df4.printSchema()

df4.createOrReplaceTempView("df4temp")

val df51 = spark.sql("""SELECT hdr.fn, hdr.line_num, hdr.val AS pfx, hdr.col_pos
                          FROM df4temp hdr
                         WHERE hdr.line_num <> 1
                           AND hdr.col_pos = 0
                     """) 
df51.show(100,false)

val df52 = spark.sql("""SELECT t1.fn, t1.val AS val1, t1.col_pos, t2.line_num, t2.val AS val2
                          FROM df4temp t1, df4temp t2
                         WHERE t1.col_pos  <> 0
                           AND t1.col_pos  = t2.col_pos 
                           AND t1.line_num <> t2.line_num
                           AND t1.line_num = 1
                           AND t1.fn       = t2.fn
                     """)
df52.show(100,false)

df51.createOrReplaceTempView("df51temp")
df52.createOrReplaceTempView("df52temp")

val df53 = spark.sql("""SELECT DISTINCT t1.pfx, t2.val1, t2.val2
                          FROM df51temp t1, df52temp t2
                         WHERE t1.fn = t2.fn 
                           AND t1.line_num = t2.line_num
                     """)
df53.show(false)

我们看到的是数据争拗，需要为tempview创建经过处理的数据，并适当地加入SQL

这里的关键是要知道如何处理数据以使事情变得简单。注意：每个文件没有groupBy等，具有不同长度的内容，在RDD中没有尝试加入，太不灵活。排名显示第#行，因此您知道0业务的第一行

这就是我们所说的数据争用。这也就是我们所说的努力工作的几点吧。这是我最大的努力之一，也是最后的努力之一

---

解决方案的缺点是要获得文件的第一条记录需要大量的工作，还有其他选择。预处理是我实际需要考虑的事情。有趣的事情，没有其他答案。不幸的是，没有，我还没有想出如何让这个工作。我希望在这里得到一些建议。我正在努力寻找，这是我所能得到的，但不确定如何实现：在我看来，你试图做的不是一个实际的支点，而是一个简单的平面图。如果您认为行标题是列名（我将它们称为c1 c2 c3…），每行是值（让我们称它们为v1 v2 v3…），那么您希望将（v1、v2、v3、v4、v5）转换为：v1、c2、v2 v1、c3、v3 v1、c4、v4等，您可以使用平面图来实现，我希望这里能为我的努力赢得一些荣誉，如果是这样的话，我们将不胜感激。这里肯定有一些想法。有趣的用例加上要应用的不同特性。可能有可能，但我看不到。我的建议是Scala比Java简单。我不知道如何给予赞扬，但非常感谢。我将很快粘贴同样的Java代码。再次感谢您接受答案，点击勾号，箭头向上。我看到您从未接受过答案，可能是时候重新审视您的所有问题，并根据本网站的协议授予分数了。你不必发布自己的答案。