Spark：通过JavaRDD元组循环-Java

我试图用一个元组循环一个JavaRDD，但是我遇到了一些问题，即如何正确地循环JavaRDD，并将我的rdd_值设置为rdd_数组中包含的元组值，无论b迭代器计数器值是多少

这是我的密码

//JavaRDD that contains Tuples
JavaRDD<Tuple5<Long, String, Float, Float, String>> rdd_array

//For loop to loop through rdd_array
for (int b=0;b<rdd_array.count();b++){

        //Need help on this line, how do I set rdd_row equal to the tuple5 in rdd_array
        Tuple5<Long, String, Float, Float, String> Value = rdd_array.;
        String id=Value._1().toString();
        String text=Value._2().toString();
        String negative_tweets=Value._3().toString();
        String positive_tweets=Value._4().toString();
        String score_tweets=Value._5().toString();
System.out.println(id+text+negative_tweets+positive_tweets+score_tweets)

}

//包含元组的JavaRDD
JavaRDD RDU数组
//对于通过rdd_阵列的循环到循环
对于（int b=0；b使用以下函数进行解析

 rdd_array.foreach(new VoidFunction<Tuple2<Long, Tuple7<String, String, String, String, String, String, String>>>() {
        @Override
        public void call(Tuple2<Long, Tuple7<String, String, String, String, String, String, String>> rdd_val) throws Exception {

            //new Tuple7<String, String, String, String, String, String, String>(text,created_at,userlocation,name,username,lat,lon);
            String id = rdd_val._1().toString();
            String text = rdd_val._2()._1().toString();
            String createdat = rdd_val._2()._2().toString();
            String userlocation = rdd_val._2()._3().toString();
            String name = rdd_val._2()._4().toString();
            String username = rdd_val._2()._5().toString();
            String lat = rdd_val._2()._6().toString();
            String lon = rdd_val._2()._7().toString();


            System.out.println("Printing Values EXTRA: "+id+text+createdat+userlocation+name+username+lat+lon);
        }
    });

rdd_array.foreach（新的VoidFunction（）{
@凌驾
公共void调用（Tuple2 rdd_val）引发异常{
//新的Tuple7（文本、创建位置、用户位置、名称、用户名、lat、lon）；
字符串id=rdd_val._1（）.toString（）；
字符串text=rdd_val._2（）._1（）.toString（）；
字符串createdat=rdd_val._2（）._2（）.toString（）；
字符串userlocation=rdd_val._2（）._3（）.toString（）；
字符串名称=rdd_val._2（）._4（）.toString（）；
字符串username=rdd_val._2（）._5（）.toString（）；
字符串lat=rdd_val._2（）._6（）.toString（）；
字符串lon=rdd_val._2（）._7（）.toString（）；
System.out.println（“额外打印值：”+id+text+createdat+userlocation+name+username+lat+lon）；
}
});
请注意，在您自己尝试回答时，您实际上是在处理一些看起来像
的问题，
K
（键）长，
V
（值）一个元组7。这与您在原始问题中提出的非常不同。最有可能的是，使用JavaPairDD可以更有效地实现这一切

从RDD开始，您可以使用

JavaPairRDD<Long,Tuple7<...>> prdd = rdd.mapToPair(...)

现在，请注意另一件事……使用更专用的类而不是泛型的
Tuple7
，不是更容易吗。至少它看起来像这样：

public class UserLocation {
  public long id;
  public String text;
  public String createdat;
  public String userlocation;
  public String name;
  public String username;
  public String lat;
  public String lon;
  @Override
  public String toString() {
    return Long.toString(id)+text+createdat+userlocation+name+username+lat+lon;
  }
}

JavaRDD<UserLocation> jrdd;
JavaPairRDD<Long,UserLocation> jprdd = jrdd.mapToPair((v)->new Tupple2<>(v.id,v));
...

jprdd
  .foreach((k,v)->{
     System.out.println(v.toString());
  });

然后，您的处理可能如下所示：

public class UserLocation {
  public long id;
  public String text;
  public String createdat;
  public String userlocation;
  public String name;
  public String username;
  public String lat;
  public String lon;
  @Override
  public String toString() {
    return Long.toString(id)+text+createdat+userlocation+name+username+lat+lon;
  }
}

JavaRDD<UserLocation> jrdd;
JavaPairRDD<Long,UserLocation> jprdd = jrdd.mapToPair((v)->new Tupple2<>(v.id,v));
...

jprdd
  .foreach((k,v)->{
     System.out.println(v.toString());
  });

javarddjrdd；
javapairddjprdd=jrdd.mapToPair（（v）->新的tuple2（v.id，v））；
...
jprdd
.foreach（（k，v）->{
System.out.println（v.toString（））；
});

一般来说，在这个例子中，将数据映射到
javapairdd
并没有真正的用途。但是，您的数据将基于长键重新分区，并且可以具有更好的并行性。
我理解RDD是不可变的。我所要做的就是读取RDD中的元组，并将它们分配给您在c中看到的变量ode代码段。我是否需要将RDD映射到元组以对其进行迭代？如果RDD甚至不能循环，人们甚至会如何对其进行任何类型的分析。因为您的循环仅用于副作用
foreach
，这可能是您想要的。关于第二个问题……高阶函数通常比eno更多呃：）@user2100493用户不应该在糟糕和诚实的第一次尝试中自动被否决，这就是这个委员会的目的。然而，遍历RDD是Spark的基础，在进行随机尝试之前应该理解它。如果做得不正确，您将永远无法真正利用多节点Spark群集的强大功能。更多信息请参阅。