Scala 如何在RDD中移动元素？

我是Scala的新手，正在尝试找出如何在RDD中移动元素。
我从CSV文件中读取这些对：

var listOfPairs = Spark.sc.textFile( <filePath> )
                  .map(aLine => aLine.split(","))
                  .map(aPair=> (aPair(0), aPair(1)))

在每个循环中，我想移动元素一次

for (i <- 1 to numberOfLoops) { ...?... }

---

以下是如何执行转换的基本思想。 这可以提高性能（特别是有一种方法可以避免多个连续轮班的多次迭代），但这是留给读者的练习

该算法的基础是为每个元素提供一个唯一的密钥，然后创建一个密钥移位的数据副本，并通过密钥连接它们

import org.apache.spark.sql.SparkSession

val spark = SparkSession.builder.master("local[1]").getOrCreate()
val sc = spark.sparkContext
import spark.implicits._

val data = sc.parallelize(List("a,1", "b,2", "c,3", "d,4", "e,5"))
val listOfPairs = data.map(_.split(",")).map { case Array(a, b) => a -> b }

val indexed = listOfPairs.zipWithIndex.map { case (tuple, idx) => idx -> tuple }
val lastIndex = indexed.count() - 1

val newIndexed = indexed.map {
  case (idx, (a, b)) =>
    if (idx == lastIndex)
      (0L, (a, b))
    else
      (idx + 1, (a, b))
}

val shifted = newIndexed.join(indexed).map {
  case (_, ((a, _), (_, b))) => a -> b
}

---

RDD是分布式集合，这种操作太难执行，效率非常低。你能告诉我为什么要这样做吗？我被要求使用RDDs，有可能吗？如果没有，也许我可以使用2D阵列。一切都是可能的，但正如我所说的，这一个将是困难和低效的。如果您认为阵列是一个合适的替代品，那么您不需要或者不了解RDD。这些是分布式集合，设计用于保存数百万条记录，其重量为TB的ram。他们通过在许多机器上分发内容来实现这一点。不管怎样，这就是为什么我问你为什么需要这个，因为可能还有其他的方法。你说你是被要求用RDD做的，这是家庭作业吗？（如果是这样的话，这是一个奇怪的问题，但可能是想做对比）嗯，这个文件有更多的记录，我只放了几行。是的，这是一个家庭作业。

[(a,1),(b,2),(c,3),(d,4),(e,5)]  
1: [ (b,2), (c,3), (d,4), (e,5), (a,1) ]  
2: [ (c,3), (d,4), (e,5), (a,1), (b,2) ]  
3: [ (d,4), (e,5), (a,1), (b,2), (c,3) ]  

import org.apache.spark.sql.SparkSession

val spark = SparkSession.builder.master("local[1]").getOrCreate()
val sc = spark.sparkContext
import spark.implicits._

val data = sc.parallelize(List("a,1", "b,2", "c,3", "d,4", "e,5"))
val listOfPairs = data.map(_.split(",")).map { case Array(a, b) => a -> b }

val indexed = listOfPairs.zipWithIndex.map { case (tuple, idx) => idx -> tuple }
val lastIndex = indexed.count() - 1

val newIndexed = indexed.map {
  case (idx, (a, b)) =>
    if (idx == lastIndex)
      (0L, (a, b))
    else
      (idx + 1, (a, b))
}

val shifted = newIndexed.join(indexed).map {
  case (_, ((a, _), (_, b))) => a -> b
}