103

目前正在学习 Scala,需要反转一个 Map 来做一些反转的 value->key 查找。我一直在寻找一种简单的方法来做到这一点,但只想出了:

(Map() ++ origMap.map(kvp=>(kvp._2->kvp._1)))

有人有更优雅的方法吗?

4

10 回答 10

186

假设值是唯一的,这有效:

(Map() ++ origMap.map(_.swap))

然而,在 Scala 2.8 上,它更容易:

origMap.map(_.swap)

能够做到这一点是 Scala 2.8 拥有新集合库的部分原因。

于 2010-02-25T23:59:57.260 回答
49

在数学上,映射可能是不可逆的(内射),例如,从Map[A,B],你不能得到Map[B,A],而是你得到Map[B,Set[A]],因为可能有不同的键与相同的值相关联。因此,如果您有兴趣了解所有密钥,请查看以下代码:

val m = Map(1 -> "a", 2 -> "b", 4 -> "b")
m.groupBy(_._2).mapValues(_.keys)

res0: Map[String,Iterable[Int]] = Map(b -> Set(2, 4), a -> Set(1))

从 scala 2.13 开始,这变得更加简单和高效:

m.groupMap(_._2)(_._1)
于 2014-06-14T17:01:06.823 回答
10

您可以在以几种方式进行迭代时避免 ._1 的东西。

这是一种方法。这使用了一个部分函数,​​该函数涵盖了对地图很重要的唯一一种情况:

Map() ++ (origMap map {case (k,v) => (v,k)})

这是另一种方式:

import Function.tupled        
Map() ++ (origMap map tupled {(k,v) => (v,k)})

map 迭代调用具有两个元素元组的函数,而匿名函数需要两个参数。Function.tupled 进行翻译。

于 2010-02-25T23:24:40.370 回答
7

好的,这是一个非常古老的问题,有很多很好的答案,但我已经构建了终极的、万能的、万能的瑞士军刀Map逆变器,这是发布它的地方。

它实际上是两个逆变器。一个用于单个价值元素...

//from Map[K,V] to Map[V,Set[K]], traverse the input only once
implicit class MapInverterA[K,V](m :Map[K,V]) {
  def invert :Map[V,Set[K]] =
    m.foldLeft(Map.empty[V, Set[K]]) {
      case (acc,(k, v)) => acc + (v -> (acc.getOrElse(v,Set()) + k))
    }
}

...还有一个非常相似的,用于价值收集。

import scala.collection.generic.CanBuildFrom
import scala.collection.mutable.Builder
import scala.language.higherKinds

//from Map[K,C[V]] to Map[V,C[K]], traverse the input only once
implicit class MapInverterB[K,V,C[_]](m :Map[K,C[V]]
                                     )(implicit ev :C[V] => TraversableOnce[V]) {
  def invert(implicit bf :CanBuildFrom[Nothing,K,C[K]]) :Map[V,C[K]] =
    m.foldLeft(Map.empty[V, Builder[K,C[K]]]) {
      case (acc, (k, vs)) =>
        vs.foldLeft(acc) {
          case (a, v) => a + (v -> (a.getOrElse(v,bf()) += k))
        }
    }.mapValues(_.result())
}

用法:

Map(2 -> Array('g','h'), 5 -> Array('g','y')).invert
//res0: Map(g -> Array(2, 5), h -> Array(2), y -> Array(5))

Map('q' -> 1.1F, 'b' -> 2.1F, 'c' -> 1.1F, 'g' -> 3F).invert
//res1: Map(1.1 -> Set(q, c), 2.1 -> Set(b), 3.0 -> Set(g))

Map(9 -> "this", 8 -> "that", 3 -> "thus", 2 -> "thus").invert
//res2: Map(this -> Set(9), that -> Set(8), thus -> Set(3, 2))

Map(1L -> Iterator(3,2), 5L -> Iterator(7,8,3)).invert
//res3: Map(3 -> Iterator(1, 5), 2 -> Iterator(1), 7 -> Iterator(5), 8 -> Iterator(5))

Map.empty[Unit,Boolean].invert
//res4: Map[Boolean,Set[Unit]] = Map()

我希望将这两种方法都放在同一个隐式类中,但是我花在研究它的时间越多,它出现的问题就越多。

于 2018-07-16T07:19:18.393 回答
6

我来这里是为了寻找一种将 Map[A, Seq[B]] 类型的 Map 反转为 Map[B, Seq[A]] 的方法,其中新映射中的每个 B 都与旧映射中的每个 A 相关联其中 B 包含在 A 的关联序列中。

例如,
Map(1 -> Seq("a", "b"), 2-> Seq("b", "c"))
将反转为
Map("a" -> Seq(1), "b" -> Seq(1, 2), "c" -> Seq(2))

这是我的解决方案:

val newMap = oldMap.foldLeft(Map[B, Seq[A]]().withDefaultValue(Seq())) {
  case (m, (a, bs)) => bs.foldLeft(m)((map, b) => map.updated(b, m(b) :+ a))
}

其中 oldMap 是类型Map[A, Seq[B]],newMap 是类型Map[B, Seq[A]]

嵌套的 foldLefts 让我有点畏缩,但这是我能找到的最直接的方法来完成这种类型的反转。有人有更清洁的解决方案吗?

于 2013-11-05T23:15:48.237 回答
3

您可以使用以下方法反转地图:

val i = origMap.map({case(k, v) => v -> k})

这种方法的问题在于,如果您的值(现在已成为地图中的哈希键)不是唯一的,您将删除重复的值。为了显示:

scala> val m = Map("a" -> 1, "b" -> 2, "c" -> 3, "d" -> 1)
m: scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2, c -> 3, d -> 1)

// Notice that 1 -> a is not in our inverted map
scala> val i = m.map({ case(k , v) => v -> k})
i: scala.collection.immutable.Map[Int,String] = Map(1 -> d, 2 -> b, 3 -> c)

为避免这种情况,您可以先将地图转换为元组列表,然后反转,这样您就不会删除任何重复的值:

scala> val i = m.toList.map({ case(k , v) => v -> k})
i: List[(Int, String)] = List((1,a), (2,b), (3,c), (1,d))
于 2014-11-14T02:50:52.140 回答
1

在 Scala REPL 中:

scala> val m = Map(1 -> "one", 2 -> "two")
m: scala.collection.immutable.Map[Int,java.lang.String] = Map(1 -> one, 2 -> two)

scala> val reversedM = m map { case (k, v) => (v, k) }
reversedM: scala.collection.immutable.Map[java.lang.String,Int] = Map(one -> 1, two -> 2)

请注意,重复的值将被最后添加到地图的内容覆盖:

scala> val m = Map(1 -> "one", 2 -> "two", 3 -> "one")
m: scala.collection.immutable.Map[Int,java.lang.String] = Map(1 -> one, 2 -> two, 3 -> one)

scala> val reversedM = m map { case (k, v) => (v, k) }
reversedM: scala.collection.immutable.Map[java.lang.String,Int] = Map(one -> 3, two -> 2)
于 2013-10-09T00:14:37.117 回答
1

开始Scala 2.13,为了在不丢失与相同值关联的键的情况下交换键/值,我们可以使用Map新的groupMap方法,它(顾名思义)相当于 agroupBy和 amap对分组项目的 ping。

Map(1 -> "a", 2 -> "b", 4 -> "b").groupMap(_._2)(_._1)
// Map("b" -> List(2, 4), "a" -> List(1))

这:

  • groups 元素基于它们的第二个元组部分 ( _._2)(Map 的组部分)

  • maps 通过获取它们的第一个元组部分 ( ) 对项目进行分组(组Map_._1的映射部分)

这可以看作.map.groupBy(_._2).mapValues(_.map(_._1))

于 2019-02-13T23:49:04.693 回答
0
  1. 与 reverse 相比,Inverse 是此操作的更好名称(如“数学函数的逆”)

  2. 我经常不仅在地图上而且在其他(包括 Seq)集合上进行这种逆变换。我发现最好不要将逆运算的定义限制为一对一的映射。这是我对地图使用的定义(请对我的实现提出改进建议)。

    def invertMap[A,B]( m: Map[A,B] ) : Map[B,List[A]] = {
      val k = ( ( m values ) toList ) distinct
      val v = k map { e => ( ( m keys ) toList ) filter { x => m(x) == e } }
      ( k zip v ) toMap
    }
    

如果它是一个一对一的映射,您最终会得到可以简单测试并转换为 Map[B,A] 而不是 Map[B,List[A]] 的单例列表。

于 2012-05-19T09:26:26.160 回答
0

我们可以尝试使用这个foldLeft函数来处理碰撞并在单次遍历中反转地图。

scala> def invertMap[A, B](inputMap: Map[A, B]): Map[B, List[A]] = {
     |     inputMap.foldLeft(Map[B, List[A]]()) {
     |       case (mapAccumulator, (value, key)) =>
     |         if (mapAccumulator.contains(key)) {
     |           mapAccumulator.updated(key, mapAccumulator(key) :+ value)
     |         } else {
     |           mapAccumulator.updated(key, List(value))
     |         }
     |     }
     |   }
invertMap: [A, B](inputMap: Map[A,B])Map[B,List[A]]

scala> val map = Map(1 -> 2, 2 -> 2, 3 -> 3, 4 -> 3, 5 -> 5)
map: scala.collection.immutable.Map[Int,Int] = Map(5 -> 5, 1 -> 2, 2 -> 2, 3 -> 3, 4 -> 3)

scala> invertMap(map)
res0: Map[Int,List[Int]] = Map(5 -> List(5), 2 -> List(1, 2), 3 -> List(3, 4))

scala> val map = Map("A" -> "A", "B" -> "A", "C" -> "C", "D" -> "C", "E" -> "E")
map: scala.collection.immutable.Map[String,String] = Map(E -> E, A -> A, B -> A, C -> C, D -> C)

scala> invertMap(map)
res1: Map[String,List[String]] = Map(E -> List(E), A -> List(A, B), C -> List(C, D))
于 2017-12-29T00:40:29.047 回答