在Scala中使用RDD和集合

我有下面的函数，它接受Likes类型的一个数组（

typelikes=Int

） 和类型like（likesVector）数的RDD。对于likesVector RDD中的每个数字，它计算与均值数组中每个均值的距离，并选择距离最小的均值（

val distance=（mean number）.abs

）。虽然我希望得到类型为

Map[Likes，Array[Likes]]

的结果，但得到的是一个空映射<代码>映射[Likes，数组[Likes]]表示

（平均值->最接近的数字数组）

。 实现这一目标的最佳方式是什么？我怀疑这与Scala集合的易变性有很大关系

def assignDataPoints(means:Array[Likes],likesVector:RDD[Likes]): Map[Likes,Array[Likes]] ={         
        var likes_Mean = IntMap(1->1)
        var likes_mean_final = mutable.Map.empty[Likes,Array[Likes]]
        likesVector.map(dataPoint => {
          means.foldLeft(Array.empty[Likes])( (accumulator, mean)=> {
            val dist= computeDistance(dataPoint,mean)
            val nearestMean = if (dist < accumulator(0)) {
              accumulator(0)=dist
              accumulator(0)
            } else{
              accumulator(0)
            }
            val b= IntMap(nearestMean.toInt -> dataPoint)
            println("b:"+ b)
            likes_mean_final ++ likes_Mean.intersectionWith(b,(_, av, bv: Likes) => Array(av, bv))
            accumulator
          })})        
        likes_mean_final.toMap
      }

def assignDataPoints（意思是：数组[Likes]，likesVector:RDD[Likes]）：Map[Likes，数组[Likes]={
var\u Mean=IntMap（1->1）
var likes\u mean\u final=mutable.Map.empty[likes，Array[likes]]
likesVector.map（数据点=>{
means.foldLeft（Array.empty[Likes]）（（累加器，平均值）=>{
val dist=计算距离（数据点，平均值）
val nearestMean=if（距离<累加器（0））{
累加器（0）=距离
累加器（0）
}否则{
累加器（0）
}
val b=IntMap（最接近的平均值->数据点）
println（“b:+b）
likes_-mean_-final++likes_-mean.intersectionWith（b，（u，av，bv:likes）=>数组（av，bv））
累加器
})})        
喜欢你的意思
}

您的映射为空的原因是您在以下行中使用了

++

操作：

likes_mean_final ++ likes_Mean.intersectionWith(b,(_, av, bv: Likes) => Array(av, bv))

++

操作返回一个新映射，因此我们正在创建一个新对象，而不更改当前值

变异当前可变映射的操作是

++=

。因此，您应该使用：

likes_mean_final ++= likes_Mean.intersectionWith(b,(_, av, bv: Likes) => Array(av, bv))

也不需要在您的上下文中使用

var

，因为您没有将值重新分配给相同的引用

---

但是您不应该在Scala中使用可变性。

我不理解您操作的上下文。你能用一些输入和输出更新你的问题吗