Scala如何在列表中相交Map[String，Double]类型的映射：List[Map[String，Double]]

所以我有一个映射列表：list[Map[String，Double]]。 例如：

List(Map("A" -> 1.1, "B" -> 2.5, "E" -> 3.5, "C" -> 1.6, "D" -> 0.9), 
        Map("A" -> 0.8, "C" -> 2.1, "D" -> 2.8), 
        Map("C" -> 2.2, "D" -> 2.9, "A" -> 3.4), 
        Map("B" -> 0.4, "D" -> 1.8, "E" -> 0.234, "A" -> 3.7))

我想做的是将所有地图的交点放在一起，这样看起来：

   For example, for A: (1.1 + 0.8 + 3.4 + 3.7)/4 = 2.25
                for D: (0.9 + 2.8 + 2.9 + 1.8)/4 = 2.1

   List(Map("A" -> 2.25,"D" -> 2.1))

是否有办法仅使用内置函数获取上面的地图交叉列表？这些值是四个贴图组合中所有关键点的平均值。

首先尝试使用reduce只保留重复的关键点并将所有值相加，然后使用mapValues获得平均值：

val maps = List(...)

val intersected = maps
  .reduce { (m1, m2) =>
    m1.keySet.intersect(m2.keySet).map(key => (key, m1(key) + m2(key))).toMap
  }
  .view
  .mapValues(_ / maps.size)
  .toMap

类似。

首先尝试使用reduce仅保留重复的关键帧，并将所有值相加，然后使用mapValues获得平均值：

val maps = List(...)

val intersected = maps
  .reduce { (m1, m2) =>
    m1.keySet.intersect(m2.keySet).map(key => (key, m1(key) + m2(key))).toMap
  }
  .view
  .mapValues(_ / maps.size)
  .toMap

---

类似。

必须注意输入不是空的

val lm : List[Map[String,Double]] =
  List(Map("A" -> 1.1, "B" -> 2.5, "E" -> 3.5, "C" -> 1.6, "D" -> 0.9)
      ,Map("A" -> 0.8, "C" -> 2.1, "D" -> 2.8)
      ,Map("C" -> 2.2, "D" -> 2.9, "A" -> 3.4)
      ,Map("B" -> 0.4, "D" -> 1.8, "E" -> 0.234, "A" -> 3.7))

val len = lm.length
val res = if (len > 0)
            lm.map(_.keySet)
              .reduce(_ intersect _)
              .map(k => (k, lm.map(_(k)).sum/len))
              .toMap
          else Map.empty[String,Double]
//res: Map[String,Double] = Map(A -> 2.25, D -> 2.1)

---

必须注意输入不是空的

val lm : List[Map[String,Double]] =
  List(Map("A" -> 1.1, "B" -> 2.5, "E" -> 3.5, "C" -> 1.6, "D" -> 0.9)
      ,Map("A" -> 0.8, "C" -> 2.1, "D" -> 2.8)
      ,Map("C" -> 2.2, "D" -> 2.9, "A" -> 3.4)
      ,Map("B" -> 0.4, "D" -> 1.8, "E" -> 0.234, "A" -> 3.7))

val len = lm.length
val res = if (len > 0)
            lm.map(_.keySet)
              .reduce(_ intersect _)
              .map(k => (k, lm.map(_(k)).sum/len))
              .toMap
          else Map.empty[String,Double]
//res: Map[String,Double] = Map(A -> 2.25, D -> 2.1)

假设我们有：

val list = List(Map("A" -> 1.1, "B" -> 2.5, "E" -> 3.5, "C" -> 1.6, "D" -> 0.9),
  Map("A" -> 0.8, "C" -> 2.1, "D" -> 2.8),
  Map("C" -> 2.2, "D" -> 2.9, "A" -> 3.4),
  Map("B" -> 0.4, "D" -> 1.8, "E" -> 0.234, "A" -> 3.7))

另一个选项是Scala 2.13：

val stringToDoubles =
  list.flatten
    .groupMap(_._1)(_._2)
    .filter(_._2.size == list.size)
    .map(keyAndValues => (keyAndValues._1, keyAndValues._2.sum / list.size))

代码运行可在上找到

在Scala 2.12及以下版本中：

val stringToDoubles =
  list.flatten
    .groupBy(_._1)
    .filter(_._2.size == list.size)
    .map(keyAndValues => (keyAndValues._1, keyAndValues._2.map(_._2).sum / list.size))

代码运行可以在。

找到，假设我们有：

val list = List(Map("A" -> 1.1, "B" -> 2.5, "E" -> 3.5, "C" -> 1.6, "D" -> 0.9),
  Map("A" -> 0.8, "C" -> 2.1, "D" -> 2.8),
  Map("C" -> 2.2, "D" -> 2.9, "A" -> 3.4),
  Map("B" -> 0.4, "D" -> 1.8, "E" -> 0.234, "A" -> 3.7))

另一个选项是Scala 2.13：

val stringToDoubles =
  list.flatten
    .groupMap(_._1)(_._2)
    .filter(_._2.size == list.size)
    .map(keyAndValues => (keyAndValues._1, keyAndValues._2.sum / list.size))

代码运行可在上找到

在Scala 2.12及以下版本中：

val stringToDoubles =
  list.flatten
    .groupBy(_._1)
    .filter(_._2.size == list.size)
    .map(keyAndValues => (keyAndValues._1, keyAndValues._2.map(_._2).sum / list.size))

---

代码运行可以在。

中找到，如果您愿意使用外部库，那么使用CAT就变得非常简单：

---

您可以看到代码正在运行。

如果您愿意使用外部库，使用cats就变得非常简单：

---

您可以看到代码正在运行。

您所说的intersect到底是什么意思？2.25和2.1是从哪里来的？如果您已经有一个函数f与两个映射相交，那么可以执行list.reducef或list.foldLeftMapfI，以获得只需要重复的键，但是这些值的逻辑是什么？是什么意思此外，您是否对外部图书馆开放？没有std函数可以让XA开箱即用，但cata确实提供了更接近的功能。如果可能的话，没有外部库。是否可以使用intersect函数并添加其他函数来执行此操作？intersect的确切含义是什么？2.25和2.1是从哪里来的？如果您已经有一个函数f与两个映射相交，那么可以执行list.reducef或list.foldLeftMapfI，以获得只需要重复的键，但是这些值的逻辑是什么？是什么意思此外，您是否对外部图书馆开放？没有std函数可以让XA开箱即用，但cata确实提供了更接近的功能。如果可能的话，没有外部库。是否可以使用intersect函数并添加其他函数来执行此操作？哦，我忘记了输入为空的情况+1哦，我忘记了输入为空的情况+1.