反转Scala中的嵌套地图

Question

I have a Map of type Map[A, Map[B, C]] .

How can I inverse it to have a Map of type Map[B, Map[A, C]] ?

Answer 1

There are lots of ways you could define this operation. I'll walk through a couple of the ones that I find the clearest. For the first implementation I'll start with a helper method:

def flattenNestedMap[A, B, C](nested: Map[A, Map[B, C]]): Map[(A, B), C] =
  for {
    (a, innerMap) <- nested
    (b, c)        <- innerMap
  } yield (a, b) -> c

This flattens the nested map to a map from pairs to values. Next we can define another helper operation that gets us almost what we need.

def groupByBs[A, B, C](flattened: Map[(A, B), C]): Map[B, Map[(A, B), C]] =
  flattened.groupBy(_._1._2)

Now we just need to remove the redundant B from the keys in the inner map:

def invert[A, B, C](nested: Map[A, Map[B, C]]): Map[B, Map[A, C]] =
  groupByBs(flattenNestedMap(nested)).mapValues(
    _.map {
      case ((a, _), c) => a -> c
    }
  )

(Note that mapValues is lazy, which means that the result will be recomputed every time you use it. In general this isn't a problem, and there are easy workarounds, but they're not really relevant to the question.)

And we're done:

scala> invert(Map(1 -> Map(2 -> 3), 10 -> Map(2 -> 4)))
res0: Map[Int,Map[Int,Int]] = Map(2 -> Map(1 -> 3, 10 -> 4))

You could also skip the helper methods and just chain the operations in invert . I find breaking them up a little clearer, but that's a matter of style.

Alternatively you could use a couple of folds:

def invert[A, B, C](nested: Map[A, Map[B, C]]): Map[B, Map[A, C]] =
  nested.foldLeft(Map.empty[B, Map[A, C]]) {
    case (acc, (a, innerMap)) =>
      innerMap.foldLeft(acc) {
        case (innerAcc, (b, c)) =>
          innerAcc.updated(b, innerAcc.getOrElse(b, Map.empty).updated(a, c))
      }
  }

Which does the same thing:

scala> invert(Map(1 -> Map(2 -> 3), 10 -> Map(2 -> 4)))
res1: Map[Int,Map[Int,Int]] = Map(2 -> Map(1 -> 3, 10 -> 4))

The foldLeft version has more of the shape of the straightforward imperative version—we're (functionally) iterating through the key-value pairs of the outer and inner maps and building up the result. Off the top of my head I'd guess it's also a little more efficient, but I'm not sure about that, and it's unlikely to matter much, so I'd suggest choosing the one you personally find clearer.

Answer 2

You can simply do it using map operation on given Map collection :

scala> Map("A" -> Map("B" -> "C"), "X" -> Map("Y" -> "Z"))
res1: scala.collection.immutable.Map[String,scala.collection.immutable.Map[String,String]] = Map(A -> Map(B -> C), X -> Map(Y -> Z))

scala> res1.map{ case (key, valueMap) => valueMap.map{ case (vmKey, vmValue) => (vmKey -> Map(key -> vmValue)) } }
res2: scala.collection.immutable.Iterable[scala.collection.immutable.Map[String,scala.collection.immutable.Map[String,String]]] = List(Map(B -> Map(A -> C)), Map(Y -> Map(X -> Z)))