斯卡拉:如何合并地图集合
-
13-09-2019 - |
题
我有一个 Map[String, Double] 列表,我想将它们的内容合并到一个 Map[String, Double] 中。我应该如何以惯用的方式做到这一点?我想我应该能够通过折叠来做到这一点。就像是:
val newMap = Map[String, Double]() /: listOfMaps { (accumulator, m) => ... }
此外,我想以通用的方式处理按键冲突。也就是说,如果我向已存在的映射添加一个键,我应该能够指定一个返回 Double 的函数(在本例中)并获取该键的现有值以及我要添加的值。如果映射中尚不存在该键,则只需添加它并保持其值不变。
在我的具体情况下,我想构建一个 Map[String, Double] ,这样如果映射已经包含一个键,那么 Double 将被添加到现有的映射值中。
我正在我的特定代码中使用可变映射,但如果可能的话,我对更通用的解决方案感兴趣。
解决方案
这个怎么样:
def mergeMap[A, B](ms: List[Map[A, B]])(f: (B, B) => B): Map[A, B] =
(Map[A, B]() /: (for (m <- ms; kv <- m) yield kv)) { (a, kv) =>
a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv)
}
val ms = List(Map("hello" -> 1.1, "world" -> 2.2), Map("goodbye" -> 3.3, "hello" -> 4.4))
val mm = mergeMap(ms)((v1, v2) => v1 + v2)
println(mm) // prints Map(hello -> 5.5, world -> 2.2, goodbye -> 3.3)
和它在两个2.7.5和2.8.0的工作原理。
其他提示
好了,你可以这样做:
mapList reduce (_ ++ _)
除了用于碰撞的特殊要求。
既然你有特殊的要求,也许最好的是做这样的事情(2.8):
def combine(m1: Map, m2: Map): Map = {
val k1 = Set(m1.keysIterator.toList: _*)
val k2 = Set(m2.keysIterator.toList: _*)
val intersection = k1 & k2
val r1 = for(key <- intersection) yield (key -> (m1(key) + m2(key)))
val r2 = m1.filterKeys(!intersection.contains(_)) ++ m2.filterKeys(!intersection.contains(_))
r2 ++ r1
}
可以那么这种方法添加到通过皮条客我的图书馆模式地图类,并在最初的例子,而不是“++
”使用它:
class CombiningMap(m1: Map[Symbol, Double]) {
def combine(m2: Map[Symbol, Double]) = {
val k1 = Set(m1.keysIterator.toList: _*)
val k2 = Set(m2.keysIterator.toList: _*)
val intersection = k1 & k2
val r1 = for(key <- intersection) yield (key -> (m1(key) + m2(key)))
val r2 = m1.filterKeys(!intersection.contains(_)) ++ m2.filterKeys(!intersection.contains(_))
r2 ++ r1
}
}
// Then use this:
implicit def toCombining(m: Map[Symbol, Double]) = new CombiningMap(m)
// And finish with:
mapList reduce (_ combine _)
虽然这是写在2.8,所以keysIterator
2.7变为keys
,filterKeys
可能需要filter
和map
的方面来写,&
变得**
,等等,它应该不会太不同。
我很惊讶还没有人想出这个解决方案:
myListOfMaps.flatten.toMap
正是您所需要的:
- 将列表合并到单个地图
- 清除所有重复的键
例子:
scala> List(Map('a -> 1), Map('b -> 2), Map('c -> 3), Map('a -> 4, 'b -> 5)).flatten.toMap
res7: scala.collection.immutable.Map[Symbol,Int] = Map('a -> 4, 'b -> 5, 'c -> 3)
flatten
将映射列表转换为元组的平面列表, toMap
将元组列表转换为删除所有重复键的映射
我赶紧阅读这个问题,所以我不知道如果我失去了一些东西(像它为2.7.x或没有scalaz工作):
import scalaz._
import Scalaz._
val ms = List(Map("hello" -> 1.1, "world" -> 2.2), Map("goodbye" -> 3.3, "hello" -> 4.4))
ms.reduceLeft(_ |+| _)
// returns Map(goodbye -> 3.3, hello -> 5.5, world -> 2.2)
您可以更改一倍半群的定义,并得到另一种方式来累积值,及彼最大:
implicit val dbsg: Semigroup[Double] = semigroup((a,b) => math.max(a,b))
ms.reduceLeft(_ |+| _)
// returns Map(goodbye -> 3.3, hello -> 4.4, world -> 2.2)
有趣的是,与此一比特周围noodling,我得到以下的(上2.7.5):
一般地图:
def mergeMaps[A,B](collisionFunc: (B,B) => B)(listOfMaps: Seq[scala.collection.Map[A,B]]): Map[A, B] = {
listOfMaps.foldLeft(Map[A, B]()) { (m, s) =>
Map(
s.projection.map { pair =>
if (m contains pair._1)
(pair._1, collisionFunc(m(pair._1), pair._2))
else
pair
}.force.toList:_*)
}
}
但是人,即可怕与投影并迫使和toList和诸如此类的东西。另外一个问题:什么是更好的方式来处理这种内折
有关可变的地图,这是我在我的代码处理,并用较少的通用的解决方案,我得到这样的:
def mergeMaps[A,B](collisionFunc: (B,B) => B)(listOfMaps: List[mutable.Map[A,B]]): mutable.Map[A, B] = {
listOfMaps.foldLeft(mutable.Map[A,B]()) {
(m, s) =>
for (k <- s.keys) {
if (m contains k)
m(k) = collisionFunc(m(k), s(k))
else
m(k) = s(k)
}
m
}
}
这似乎有点清洁,但因为它是书面只能与可变地图工作。有趣的是,我第一次尝试上面使用/(之前我问的问题):不是foldLeft,但我得到的类型错误。我想/:和foldLeft基本上是相等的,但是编译器不停地抱怨,我需要明确的类型(M,S)。与这是怎么回事?
我写了一篇博客文章中针对此,检查出来:
http://www.nimrodstech.com/scala-map-merge/
基本上使用scalaz半组就可以实现这很容易地
看起来是这样的:
import scalaz.Scalaz._
listOfMaps reduce(_ |+| _)
开始 Scala 2.13
, ,另一个解决方案 处理重复的键 并且只是 基于标准库 在于合并 Map
s 作为序列 (flatten
)在应用新的之前 组MapReduce 运算符(顾名思义)相当于 groupBy
接下来是分组值的映射和归约步骤:
List(Map("hello" -> 1.1, "world" -> 2.2), Map("goodbye" -> 3.3, "hello" -> 4.4))
.flatten
.groupMapReduce(_._1)(_._2)(_ + _)
// Map("world" -> 2.2, "goodbye" -> 3.3, "hello" -> 5.5)
这:
flatten
s(连接)映射作为元组序列(List(("hello", 1.1), ("world", 2.2), ("goodbye", 3.3), ("hello", 4.4))
),保留所有键/值(甚至重复的键)group
s 元素基于其第一个元组部分 (_._1
)(组的一部分 团体映射减少)map
s 将值分组到其第二元组部分 (_._2
)(映射组的一部分地图减少)reduce
s 映射分组值 (_+_
)通过取它们的总和(但它可以是任何reduce: (T, T) => T
function) (减少部分groupMap减少)
这 groupMapReduce
步骤可以看作是 一次性版本 相当于:
list.groupBy(_._1).mapValues(_.map(_._2).reduce(_ + _))
一个oneliner辅助-FUNC,其使用读取几乎一样使用scalaz清洁:
def mergeMaps[K,V](m1: Map[K,V], m2: Map[K,V])(f: (V,V) => V): Map[K,V] =
(m1 -- m2.keySet) ++ (m2 -- m1.keySet) ++ (for (k <- m1.keySet & m2.keySet) yield { k -> f(m1(k), m2(k)) })
val ms = List(Map("hello" -> 1.1, "world" -> 2.2), Map("goodbye" -> 3.3, "hello" -> 4.4))
ms.reduceLeft(mergeMaps(_,_)(_ + _))
// returns Map(goodbye -> 3.3, hello -> 5.5, world -> 2.2)
为最终可读性包装在一个隐式自定义类型:
class MyMap[K,V](m1: Map[K,V]) {
def merge(m2: Map[K,V])(f: (V,V) => V) =
(m1 -- m2.keySet) ++ (m2 -- m1.keySet) ++ (for (k <- m1.keySet & m2.keySet) yield { k -> f(m1(k), m2(k)) })
}
implicit def toMyMap[K,V](m: Map[K,V]) = new MyMap(m)
val ms = List(Map("hello" -> 1.1, "world" -> 2.2), Map("goodbye" -> 3.3, "hello" -> 4.4))
ms reduceLeft { _.merge(_)(_ + _) }