2

我有一个要转换成一对地图的数据序列；每个映射代表原始序列的单独转换。我可以生成元组，这些元组将在原始输入序列的单次传递中构成每个映射，如下所示：

val entries: Seq[((A, B), (A, C))] = input map { x =>
  val key = genKey(x)
  val tuple1 = key -> f(x)
  val tuple2 = key -> g(x)
}

我可以通过两次遍历生成的 seq 来单独创建每个映射，如下所示：

val map1 = (entries map { case(e1, _) => e1 }).toMap
val map2 = (entries map { case(_, e2) => e2 }).toMap

我认为可能有一种方法可以在地图上一次完成整个转换，这样我就可以做这样的事情：

val (map1, map2) = (entries accumulate { case(e1, e2) => // add e1 to map1, add e2 to map2 })

foldLeft 可能会这样做，但也许有更优雅的东西？

4

3 回答 3

4

使用标准库：

val (map1, map2) = entries.unzip match {
  case (pairs1, pairs2) => (pairs1.toMap, pairs2.toMap)
}

使用Scalaz，它是一条线：

val (map1, map2) = entries.unzip.bimap(_.toMap, _.toMap)

不过，这两种解决方案都会创建两个额外的中间序列。这可能不是您需要担心的事情，但如果您真的想避免它，折叠实际上并没有那么不雅：

val (map1, map2) = entries.foldLeft(Map.empty[A, B], Map.empty[A, C]) {
  case ((map1, map2), (pair1, pair2)) => (map1 + pair1, map2 + pair2)
}

不需要 Scalaz。

于 2013-11-05T21:21:57.963 回答
2

如果您想使用entries上面的方法，那么显而易见的方法是：

val (s1, s2) = entries.unzip
val map1 = s1.toMap
val map2 = s2.toMap

但是，您仍然（1）遍历您inputs以创建元组序列，然后（2）再次遍历 in unzip，然后（3）遍历 in s1.toMap，以及（4）再次遍历 in s2.toMap。

如果您关心的是最少的遍历，正如您的问题所暗示的那样，您需要手动构建结果。优雅，不，但直截了当，你可以取消你的entries方法。

val (map1, map2) = {
  val b1, b2 = Map.newBuilder[Int, String]
  input foreach { i =>
    val k = genKey(i)
    b1 += k -> f(i)
    b2 += k -> g(i)
  }
  (b1.result, b2.result)
}
于 2013-11-05T21:52:42.833 回答
-1

这将是我的方法（恕我直言，初学者更容易掌握）：

object TupleTest {

  def transform[A, B, C](entries: Seq[((A, B), (A, C))]): (Map[A, B], Map[A, C]) =
    {

      def acc[A, B, C](entries: Seq[((A, B), (A, C))], map1: Map[A, B], map2: Map[A, C]): (Map[A, B], Map[A, C]) =
        {
          entries match {
            case Nil => (map1, map2)
            case hd :: tl => acc(tl, map1.+(hd._1), map2.+(hd._2))
          }

        }
      acc(entries, Map.empty[A, B], Map.empty[A, C])

    }

}
于 2013-11-05T21:46:37.880 回答