Scala 将RDD类型从`org.apache.spark.RDD.RDD[（（字符串，字符串，双精度）]`转换为`org.apache.spark.RDD.RDD[（（字符串，列表[双精度]）]`

我有一个RDD：

  val rdd: org.apache.spark.rdd.RDD[((String, String), Double)] =
    sc.parallelize(List(
      (("a", "b"), 1.0),
      (("a", "c"), 3.0),
      (("a", "d"), 2.0)
      )) 

我正在尝试将此RDD从类型

org.apache.spark.RDD.RDD[（（字符串，字符串），双精度）]

转换为

org.apache.spark.RDD.RDD[（（字符串），List[Double]）]

RDD中的每个键都应该是唯一的，并且其值应该排序

因此，上述

rdd

结构将转换为：

val newRdd : [((String), List[Double])] = RDD("a" , List(1,2,3))

要获得我使用的密钥的唯一列表，请执行以下操作：

val r2 : org.apache.spark.rdd.RDD[(String, Double)] =  rdd.map(m => (m._1._1 , m._2))

如何将每个键转换为包含已排序双精度的列表

完整代码：

import org.apache.spark.SparkContext;

object group {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet

  val conf = new org.apache.spark.SparkConf()
    .setMaster("local")
    .setAppName("distances")
    .setSparkHome("C:\\spark-1.1.0-bin-hadoop2.4\\spark-1.1.0-bin-hadoop2.4")
    .set("spark.executor.memory", "1g")           //> conf  : org.apache.spark.SparkConf = org.apache.spark.SparkConf@1bd0dd4

  val sc = new SparkContext(conf)                 //> 14/12/16 16:44:56 INFO spark.SecurityManager: Changing view acls to: a511381
                                                  //| ,
                                                  //| 14/12/16 16:44:56 INFO spark.SecurityManager: Changing modify acls to: a5113
                                                  //| 81,
                                                  //| 14/12/16 16:44:56 INFO spark.SecurityManager: SecurityManager: authenticatio
                                                  //| n disabled; ui acls disabled; users with view permissions: Set(a511381, ); u
                                                  //| sers with modify permissions: Set(a511381, )
                                                  //| 14/12/16 16:44:57 INFO slf4j.Slf4jLogger: Slf4jLogger started
                                                  //| 14/12/16 16:44:57 INFO Remoting: Starting remoting
                                                  //| 14/12/16 16:44:57 INFO Remoting: Remoting started; listening on addresses :[
                                                  //| akka.tcp://sparkDriver@LA342399.dmn1.fmr.com:51092]
                                                  //| 14/12/16 16:44:57 INFO Remoting: Remoting now listens on addresses: [akka.tc
                                                  //| p://sparkDriver@LA342399.dmn1.fmr.com:51092]
                                                  //| 14/12/16 16:44:57 INFO util.Utils: Successfully started service 'sparkDriver
                                                  //| ' on port 51092.
                                                  //| 14/12/16 16:44:57 INFO spark.SparkEnv: Registering MapOutputTracker
                                                  //| 14/12/16 16:44:57 INFO spark.SparkEnv:
                                                  //| Output exceeds cutoff limit.

  val rdd: org.apache.spark.rdd.RDD[((String, String), Double)] =
    sc.parallelize(List(
      (("a", "b"), 1.0),
      (("a", "c"), 3.0),
      (("a", "d"), 2.0)
      ))                                          //> rdd  : org.apache.spark.rdd.RDD[((String, String), Double)] = ParallelCollec
                                                  //| tionRDD[0] at parallelize at group.scala:15

     val r2 : org.apache.spark.rdd.RDD[(String, Double)] =  rdd.map(m => (m._1._1 , m._2))
                                                  //> r2  : org.apache.spark.rdd.RDD[(String, Double)] = MappedRDD[1] at map at gr
                                                  //| oup.scala:21

     val m1 = r2.collect                          //> 14/12/16 16:44:59 INFO spark.SparkContext: Starting job: collect at group.sc
                                                  //| ala:23
                                                  //| 14/12/16 16:44:59 INFO scheduler.DAGScheduler: Got job 0 (collect at group.s
                                                  //| cala:23) with 1 output partitions (allowLocal=false)
                                                  //| 14/12/16 16:44:59 INFO scheduler.DAGScheduler: Final stage: Stage 0(collect 
                                                  //| at group.scala:23)
                                                  //| 14/12/16 16:44:59 INFO scheduler.DAGScheduler: Parents of final stage: List(
                                                  //| )
                                                  //| 14/12/16 16:44:59 INFO scheduler.DAGScheduler: Missing parents: List()
                                                  //| 14/12/16 16:44:59 INFO scheduler.DAGScheduler: Submitting Stage 0 (MappedRDD
                                                  //| [1] at map at group.scala:21), which has no missing parents
                                                  //| 14/12/16 16:44:59 WARN util.SizeEstimator: Failed to check whether UseCompre
                                                  //| ssedOops is set; assuming yes
                                                  //| 14/12/16 16:44:59 INFO storage.MemoryStore: ensureFreeSpace(1584) called wit
                                                  //| h curMem=0, maxMem=140142182
                                                  //| 14/12/16 16:44:59 INFO storage.MemoryStore: Block broadcast_0 stored as valu
                                                  //| es in memory (estimated size 1584.0 B
                                                  //| Output exceeds cutoff limit.
     m1.foreach { case (e, i) => println(e + "," + i) }
                                                  //> a,1.0
                                                  //| a,3.0
                                                  //| a,2.0


}

---

使用

groupByKey

：

val r3: RDD[String, Iterable[Double]] = r2.groupByKey

如果您确实希望第二个元素是

列表

而不是常规的

Iterable

，则可以使用

mapValues

val r4 = r3.mapValues(_.toList)

---

确保在顶部导入org.apache.spark.SparkContext.\u，以便这些功能可用。

使用

groupByKey

：

val r3: RDD[String, Iterable[Double]] = r2.groupByKey

如果您确实希望第二个元素是

列表

而不是常规的

Iterable

，则可以使用

mapValues

val r4 = r3.mapValues(_.toList)

---

确保在顶部导入org.apache.spark.SparkContext.\u，以便这些功能可用。

使用

groupByKey

：

val r3: RDD[String, Iterable[Double]] = r2.groupByKey

如果您确实希望第二个元素是

列表

而不是常规的

Iterable

，则可以使用

mapValues

val r4 = r3.mapValues(_.toList)

---

确保在顶部导入org.apache.spark.SparkContext.\u，以便这些功能可用。

使用

groupByKey

：

val r3: RDD[String, Iterable[Double]] = r2.groupByKey

如果您确实希望第二个元素是

列表

而不是常规的

Iterable

，则可以使用

mapValues

val r4 = r3.mapValues(_.toList)

---

确保在顶部导入org.apache.spark.SparkContext.\u以便这些函数可用。

Hi使用@Imm解决方案时，您的值将不会被排序，如果发生这种情况，将造成伤亡。 要获得排序列表，您只需添加：

val r4=r3.mapValues（u.toList.sorted） 因此r4将有一个rdd，每个值列表将针对每个键进行排序

---

我希望这将是有用的

嗨，对于@Imm解决方案，您的值不会被排序，如果发生这种情况，将是一个牺牲品。 要获得排序列表，您只需添加：

val r4=r3.mapValues（u.toList.sorted） 因此r4将有一个rdd，每个值列表将针对每个键进行排序

---

我希望这将是有用的

嗨，对于@Imm解决方案，您的值不会被排序，如果发生这种情况，将是一个牺牲品。 要获得排序列表，您只需添加：

val r4=r3.mapValues（u.toList.sorted） 因此r4将有一个rdd，每个值列表将针对每个键进行排序

---

我希望这将是有用的

嗨，对于@Imm解决方案，您的值不会被排序，如果发生这种情况，将是一个牺牲品。 要获得排序列表，您只需添加：

val r4=r3.mapValues（u.toList.sorted） 因此r4将有一个rdd，每个值列表将针对每个键进行排序

---

我希望这将是有用的

为了完全回答上述问题，您也应该对列表进行排序。@lmm“val r3:RDD[String，Iterable[Double]]=r2.groupByKey”导致编译器错误：“org.apache.spark.RDD.RDD的类型参数的数目错误，应该是1”，因此我将RDD类型包装成一个元组：val r3:org.apache.spark.RDD.RDD.RDD[（String，Iterable[Double]）]=r2.groupByKey要完全回答上述问题，您还应该对列表进行排序。@lmm“val r3:RDD[String，Iterable[Double]=r2.groupByKey”导致编译器错误：“org.apache.spark.RDD.RDD的类型参数的数目错误，应该是1”，因此我将RDD类型包装成一个元组：val r3:org.apache.spark.RDD.RDD.RDD[（String，Iterable[Double]）]=r2.groupByKey要完全回答上述问题，您还应该对列表进行排序。@lmm“val r3:RDD[String，Iterable[Double]=r2.groupByKey”导致编译器错误：“org.apache.spark.RDD.RDD的类型参数的数目错误，应该是1”，因此我将RDD类型包装成一个元组：val r3:org.apache.spark.RDD.RDD.RDD[（String，Iterable[Double]）]=r2.groupByKey要完全回答上述问题，您还应该对列表进行排序。@lmm“val r3:RDD[String，Iterable[Double]=r2.groupByKey”导致编译器错误：“org.apache.spark.RDD.RDD的类型参数的数目错误，应该是1”，因此我将RDD类型包装成一个元组：val r3:org.apache.spark.RDD.RDD.RDD[（字符串，Iterable[Double]）]=r2.groupByKey