首页 文章

Scala：按键合并 Map

提问于
浏览 次
22

说我有两张 Map ：

val a = Map(1 -> "one", 2 -> "two", 3 -> "three")
val b = Map(1 -> "un", 2 -> "deux", 3 -> "trois")

我想通过键合并这些映射，应用一些函数来收集值（在这种特殊情况下，我想将它们收集到一个seq中，给出：

val c = Map(1 -> Seq("one", "un"), 2->Seq("two", "deux"), 3->Seq("three", "trois"))

感觉应该有一个很好的，惯用的方式来做这个 - 任何建议？如果解决方案涉及scalaz，我很高兴 .

scala functional-programming maps scalaz

6 回答

  • 14

    scala.collection.immutable.IntMap有一个 intersectionWith 方法，可以完全按照您的要求（我相信）：

    import scala.collection.immutable.IntMap

val a = IntMap(1 -> "one", 2 -> "two", 3 -> "three", 4 -> "four")
val b = IntMap(1 -> "un", 2 -> "deux", 3 -> "trois")

val merged = a.intersectionWith(b, (_, av, bv: String) => Seq(av, bv))

    这给你 IntMap(1 -> List(one, un), 2 -> List(two, deux), 3 -> List(three, trois)) . 请注意，它正确地忽略了仅在 a 中出现的键 .

    作为旁注：我经常发现自己想要Scala中Haskell's Data.Map的 unionWith ， intersectionWith 等函数 . 我没有't think there'的任何原则性原因，它们只应在 IntMap 上，而不是在 collection.Map 基础上 .

    回复于
  • 1
    val a = Map(1 -> "one", 2 -> "two", 3 -> "three")
val b = Map(1 -> "un", 2 -> "deux", 3 -> "trois")

val c = a.toList ++ b.toList
val d = c.groupBy(_._1).map{case(k, v) => k -> v.map(_._2).toSeq}
//res0: scala.collection.immutable.Map[Int,Seq[java.lang.String]] =
        //Map((2,List(two, deux)), (1,List(one, un), (3,List(three, trois)))
    回复于
  • 19

    Scalaz为 A 添加了一个方法 |+| ，其中 Semigroup[A] 可用 .

    如果您映射 Map 以使每个值都是单个元素序列，那么您可以非常简单地使用它：

    scala> a.mapValues(Seq(_)) |+| b.mapValues(Seq(_))
res3: scala.collection.immutable.Map[Int,Seq[java.lang.String]] = Map(1 -> List(one, un), 2 -> List(two, deux), 3 -> List(three, trois))
    回复于
  • 2

    所以我对这两种解决方案都不太满意（我想 Build 一个新类型，所以半群并不真正感觉合适，而Infinity的解决方案看起来相当复杂），所以我暂时还没有这个 . 我很高兴看到它有所改善：

    def merge[A,B,C](a : Map[A,B], b : Map[A,B])(c : (B,B) => C) = {
  for (
    key <- (a.keySet ++ b.keySet);
    aval <- a.get(key); bval <- b.get(key)
  ) yield c(aval, bval)
}
merge(a,b){Seq(_,_)}

    我想要在任何一个映射中都没有键时返回任何内容的行为（这与其他解决方案不同），但是指定它的方法会很好 .

    回复于
  • 18

    在寻找其他解决方案之前，这是我的第一个方法：

    for (x <- a) yield 
  x._1 -> Seq (a.get (x._1), b.get (x._1)).flatten

    为了避免碰巧只存在于a或b中的元素，过滤器很方便：

    (for (x <- a) yield 
  x._1 -> Seq (a.get (x._1), b.get (x._1)).flatten).filter (_._2.size == 2)

    需要展平，因为b.get（x._1）返回一个选项 . 为了使展平工作，第一个元素也必须是一个选项，所以我们不能在这里使用x._2 .

    对于序列，它也有效：

    scala> val b = Map (1 -> Seq(1, 11, 111), 2 -> Seq(2, 22), 3 -> Seq(33, 333), 5 -> Seq(55, 5, 5555))
b: scala.collection.immutable.Map[Int,Seq[Int]] = Map(1 -> List(1, 11, 111), 2 -> List(2, 22), 3 -> List(33, 333), 5 -> List(55, 5, 5555))

scala> val a = Map (1 -> Seq(1, 101), 2 -> Seq(2, 212, 222), 3 -> Seq (3, 3443), 4 -> (44, 4, 41214))
a: scala.collection.immutable.Map[Int,ScalaObject with Equals] = Map(1 -> List(1, 101), 2 -> List(2, 212, 222), 3 -> List(3, 3443), 4 -> (44,4,41214))

scala> (for (x <- a) yield x._1 -> Seq (a.get (x._1), b.get (x._1)).flatten).filter (_._2.size == 2) 
res85: scala.collection.immutable.Map[Int,Seq[ScalaObject with Equals]] = Map(1 -> List(List(1, 101), List(1, 11, 111)), 2 -> List(List(2, 212, 222), List(2, 22)), 3 -> List(List(3, 3443), List(33, 333)))
    回复于
  • 1
    val fr = Map(1 -> "one", 2 -> "two", 3 -> "three")
val en = Map(1 -> "un", 2 -> "deux", 3 -> "trois")

def innerJoin[K, A, B](m1: Map[K, A], m2: Map[K, B]): Map[K, (A, B)] = {
  m1.flatMap{ case (k, a) => 
    m2.get(k).map(b => Map((k, (a, b)))).getOrElse(Map.empty[K, (A, B)])
  }
}

innerJoin(fr, en) // Map(1 -> ("one", "un"), 2 -> ("two", "deux"), 3 -> ("three", "trois")): Map[Int, (String, String)]
    回复于

相关问题