Scala 中的嵌套默认映射

Question

我正在尝试在 Scala 中构造嵌套映射，其中外部映射和内部映射都使用“withDefaultValue”方法。例如，以下内容：

val m = HashMap.empty[Int, collection.mutable.Map[Int,Int]].withDefaultValue( HashMap.empty[Int,Int].withDefaultValue(3))
m(1)(2)
res: Int = 3
m(1)(2) = 5
m(1)(2) 
res: Int = 5
m(2)(3) = 6
m
res : scala.collection.mutable.Map[Int,scala.collection.mutable.Map[Int,Int]] = Map()

因此，当通过适当的键寻址时，地图会返回我输入的内容。但是，地图本身显示为空！在此示例中，甚至 m.size 也返回 0。谁能解释一下这是怎么回事？

Answer 1

简短的回答

这绝对不是一个错误。

长答案

withDefaultValue 的行为是在 Map 中存储默认值（在您的情况下是可变映射），以便在键不存在时返回。这与未找到键时插入到 Map 中的值不同。

让我们仔细看看发生了什么。如果我们将默认映射作为单独的变量取出，以便我们可以随意检查，会更容易理解；我们称其为 default

import collection.mutable.HashMap
val default = HashMap.empty[Int,Int].withDefaultValue(3)

所以 default 是一个可变映射（有自己的默认值）。现在我们可以创建 m 并指定 default 作为默认值。

import collection.mutable.{Map => MMap}
val m = HashMap.empty[Int, MMap[Int,Int]].withDefaultValue(default)

现在，每当使用丢失的密钥访问 m 时，它将返回 default。请注意，这与您的行为完全相同，因为 withDefaultValue 定义为：

def withDefaultValue (d: B): Map[A, B]

注意，它是 d: B 而不是 d: =>; B，所以每次默认访问时不会创建新的地图；它将返回完全相同的对象，我们称之为default。

让我们看看会发生什么：

m(1) // Map()

由于键 1 不在 m 中，因此返回默认值 default。此时的default是一个空的Map。

m(1)(2) = 5

由于 m(1) 返回 default，因此此操作将 5 作为键 2 的值存储在 default 中。没有向 Map m 写入任何内容，因为 m(1) 解析为 default，它完全是一个单独的 Map。我们可以通过查看 default 来检查这一点：

default // Map(2 -> 5)

但正如我们所说，m 保持不变

m // Map()

---

现在，如何实现您真正想要的？您不想使用 withDefaultValue，而是希望使用 getOrElseUpdate：

def getOrElseUpdate (key: A, op: ⇒ B): B

注意我们如何看到 op: => B？这意味着每次需要时都会重新评估参数 op。这允许我们在其中放置一个新的 Map，并使其成为每个无效键的单独的新 Map。让我们看一下：

val m2 = HashMap.empty[Int, MMap[Int,Int]]

这里不需要默认值。

m2.getOrElseUpdate(1, HashMap.empty[Int,Int].withDefaultValue(3)) // Map()

键 1 不存在，因此我们插入一个新的 HashMap，并返回该新值。我们可以检查它是否按照我们的预期插入。请注意，1 映射到新添加的空映射，并且由于上面解释的行为，它们 3 没有添加到任何地方。

m2 // Map(1 -> Map())

同样，我们可以按预期更新地图：

m2.getOrElseUpdate(1, HashMap.empty[Int,Int].withDefaultValue(1))(2) = 6

并检查它是否已添加：

m2 // Map(1 -> Map(2 -> 6))

Answer 2

withDefaultValue 用于在未找到键时返回值。它不会填充地图。所以你的地图保持空白。有点像使用 getOrElse(a, b)，其中 b 由 withDefaultValue 提供。

Answer 3

我刚刚遇到了完全相同的问题，很高兴找到 dhg 的答案。由于一直输入 getOrElseUpdate 不太简洁，所以我想出了这个我想分享的想法的小扩展：
您可以声明一个使用 getOrElseUpdate 作为 () 运算符的默认行为的类：

class DefaultDict[K, V](defaultFunction: (K) => V) extends HashMap[K, V] {
  override def default(key: K): V = return defaultFunction(key)
  override def apply(key: K): V = 
    getOrElseUpdate(key, default(key))
}

现在您可以像这样执行您想要执行的操作：

var map = new DefaultDict[Int, DefaultDict[Int, Int]](
  key => new DefaultDict(key => 3))
map(1)(2) = 5

现在，这会导致 map 包含 5 （或者更确切地说：包含DefaultDict 包含键 2) 的值 5。

Answer 4

您所看到的是您创建了一个 Map[Int, Int] 的效果，只要键不在外部映射中，这就是默认值。

scala> val m = HashMap.empty[Int, collection.mutable.Map[Int,Int]].withDefaultValue( HashMap.empty[Int,Int].withDefaultValue(3))
m: scala.collection.mutable.Map[Int,scala.collection.mutable.Map[Int,Int]] = Map()

scala> m(2)(2)
res1: Int = 3

scala> m(1)(2) = 5

scala> m(2)(2)
res2: Int = 5

为了获得您正在寻找的效果，您必须使用一个实现来包装 Map，当在 Map 中找不到某个键时，该实现实际上会插入默认值代码>.

编辑：

我不确定您的实际用例是什么，但使用一对作为单个 Map.

scala> val m = HashMap.empty[(Int, Int), Int].withDefaultValue(3)
m: scala.collection.mutable.Map[(Int, Int),Int] = Map()

scala> m((1, 2))
res0: Int = 3

scala> m((1, 2)) = 5

scala> m((1, 2))
res3: Int = 5

scala> m
res4: scala.collection.mutable.Map[(Int, Int),Int] = Map((1,2) -> 5)

Answer 5

我知道有点晚了，但我刚刚在尝试解决同样的问题时看到了该帖子。
该 API 可能与 2012 版本不同，但您可能希望使用 withDefault 而不是 withDefaultValue。
不同之处在于 withDefault 采用一个函数作为参数，每次请求丢失的按键时都会执行该函数；）