2

我有一个清单

    val l : List[Map[String,Any]] = List(Map("a" -> 1, "b" -> 2.8), Map("a" -> 3, "c" -> 4), Map("c" -> 5, "d" -> "abc"))

我使用以下代码来查找键“a”（Int）、“b”（Double）和“c”（Int）的总和。“d”作为噪声包括在内。

    l.map(n => n.mapValues( v => if (v.isInstanceOf[Number]) {v match {
    case x:Int => x.asInstanceOf[Int]
    case x:Double => x.asInstanceOf[Double]
    }} else 0)).foldLeft((0,0.0,0))((t, m) => (
t._1 +  m.get("a").getOrElse(0), 
t._2 + m.get("b").getOrElse(0.0), 
t._3 + m.get("c").getOrElse(0)))

我希望输出是 (4, 2.8, 9) 但我却被垃圾

<console>:10: error: overloaded method value + with alternatives:
  (x: Int)Int <and>
  (x: Char)Int <and>
  (x: Short)Int <and>
  (x: Byte)Int
 cannot be applied to (AnyVal)

我认为例外是试图告诉我“+”不适用于 AnyVal。我如何让它发挥作用以获得我想要的结果？谢谢

4

6 回答 6

6 
m.foldLeft(0)(_+_._2)

这是一个非常清晰和简单的解决方案。参考： http: //ktuman.blogspot.com/2009/10/how-to-simply-sum-values-in-map-in.html

于 2016-06-15T09:42:12.003 回答
5

您可以使用 foldLeft 函数：

scala> val l : List[Map[String,Any]] = List(Map("a" -> 1, "b" -> 2.8), Map("a" -> 3, "c" -> 4), Map("c" -> 5, "d" -> "abc"))
l: List[Map[String,Any]] = List(Map(a -> 1, b -> 2.8), Map(a -> 3, c -> 4), Map(c -> 5, d -> abc))

scala> val (sa, sb, sc) = l.foldLeft((0: Int, 0: Double, 0: Int)){
     |   case ((a, b, c), m) => (
     |     a + m.get("a").collect{case i: Int => i}.getOrElse(0),
     |     b + m.get("b").collect{case i: Double => i}.getOrElse(0.),
     |     c + m.get("c").collect{case i: Int => i}.getOrElse(0)
     |     )
     |   }
sa: Int = 4
sb: Double = 2.8
sc: Int = 9

使用 incrop 的想法collect而不是match.

于 2012-04-04T09:27:28.743 回答
3

首先，您完全错过了模式匹配的重点

{case i: Int => i
 case d: Double => d
 case _ => 0}

是你里面所有函数的正确替换mapValues。然而这不是问题所在，你的写作虽然复杂，但也有同样的作用。

您的函数在mapValues返回Double（因为一些分支返回Int而其他分支返回Double，在这种情况下，Int被提升为Double。如果不是，它将返回AnyVal）。所以你得到一个List[Map[String, Double]]. 在这一点上，你已经失去了 Ints。

当你这样做时m.get("a")，这将返回Option[Double]。Option[A] has method getOrElse(default: A) : A（实际上，default: => X）但在这里没有区别）。

如果你打电话getOrElse(0.0)而不是getOrElse(0)，你会得到一个 Double。您的代码仍然失败，因为您的折叠以（Int，Double，Double）开头，您将返回（Double，Double，Double）。如果你以 (0.0, 0.0, 0.0) 开始弃牌，它会起作用，但你失去了 Ints，你会得到 (4.0, 2.8, 9.0)

现在，关于错误消息。您将 Int 传递给需要 Double (getOrElse) 的方法，Int 通常应转换为 Double，就好像您使用getOrElse(0.0). 除了Option是协变的（声明的trait Option[+A]）。如果X是 的祖先A， anOption[A]也是Option[X]. 所以一个 Option[Double]也是Option[AnyVal]and Option[Any]。getOrElse(0)如果选项被认为是，则调用有效Option[AnyVal]，结果是AnyVal（也可以使用Any，但AnyVal更精确，这是编译器选择的那个）。因为表达式按原样编译，所以不需要提升0to 0.0。因此m.get("a").getOrElse(0)是类型AnyVal，不能添加到t._1. 这就是您的错误消息所说的。

您知道“a”与 Int 相关联，“b”与 double 相关联，但您没有将此知识传递给编译器。

于 2012-04-04T09:55:13.257 回答
0

一般来说，如果您不知道键，但只想对值求和，您可以这样做

val filtered = for {
    map <- l
    (k, v) <- map
    if v.isInstanceOf[Number]
  } yield k -> v.asInstanceOf[Number].doubleValue

val summed = filtered.groupBy(_._1) map { case (k, v) => k -> v.map(_._2).sum }

scala> l
res1: List[Map[String,Any]] = List(Map(a -> 1, b -> 2.8), Map(a -> 3, c -> 4), Map(c -> 5, d -> abc))

scala> filtered
res2: List[(String, Double)] = List((a,1.0), (b,2.8), (a,3.0), (c,4.0), (c,5.0))

scala> summed
res3: Map[String,Double] = Map(c -> 9.0, a -> 4.0, b -> 2.8)

更新

您可以按您想要的类型过滤地图，例如

scala> val intMap = for (x <- l) yield x collect { case (k, v: Int) => k -> v }
intMap: List[scala.collection.immutable.Map[String,Int]] = List(Map(a -> 1), Map(a -> 3, c -> 4), Map(c -> 5))

然后对值求和（参见链接问题）

scala> intMap reduce { _ |+| _ }
res4: scala.collection.immutable.Map[String,Int] = Map(a -> 4, c -> 9)
于 2012-04-04T09:50:55.187 回答
0

一个漂亮的单行：

l.map(_.filterKeys(_ != "d")).flatten groupBy(_._1) map { case (k,v) => v map { case (k2,v2: Number) => v2.doubleValue} sum }

res0: scala.collection.immutable.Iterable[Double] = List(9.0, 4.0, 2.8)
于 2012-04-04T16:11:06.070 回答
-2

我是否遗漏了什么，或者你不能只做：

map.values.sum

?

于 2015-08-25T09:19:04.910 回答