从2个表格列表List[(Int, String):
l1 = List((1,"a"),(3,"b"))
l2 = List((3,"a"),(4,"c"))
如何组合Integers String相同的s来获得第三个列表:
l3 = List((4,"a"),(3,"b"),(4,"c"))
现在我正在遍历两个列表并添加字符串是否相同,但我认为应该有一个简单的模式匹配解决方案.
我试图合并多个哈希图也总和相同键的值,ı想用玩具示例解释我的问题如下
HashMap<String, Integer> m = new HashMap<>();
HashMap<String, Integer> m2 = new HashMap<>();
m.put("apple", 2);
m.put("pear", 3);
m2.put("apple", 9);
m2.put("banana", 6);
我试过putall
m.putAll(M2);
输出如下{banana = 6,apple = 9,pear = 3}
但它的结果不适用于这个问题.我希望输出为
{banana = 6,apple = 11,pear = 3}
怎么能在java中得到这个结果？
在scala中,如何定义两个Option参数的加法？具体来说,让我们说它们是Int类型的包装器(我实际上使用的是双打映射,但这个例子更简单).
我尝试了以下但它只是给了我一个错误:
def addOpt(a:Option[Int], b:Option[Int]) = {
a match {
case Some(x) => x.get
case None => 0
} + b match {
case Some(y) => y.get
case None => 0
}
}
编辑添加:
在我的实际问题中,我添加了两个映射,这些映射是稀疏矢量的替换.因此,无案例返回Map [Int,Double],而+实际上是++(在stackoverflow.com/a/7080321/614684处调整)
我有一个3元组列表,如下所示[我为可读性添加了换行符]:
(2, 127, 3)
(12156, 127, 3)
(4409, 127, 2) <-- 4409 occurs 2x
(1312, 127, 12) <-- 1312 occurs 3x
(4409, 128, 1) <--
(12864, 128, 1)
(1312, 128, 1) <--
(2664, 128, 2)
(12865, 129, 1)
(183, 129, 1)
(12866, 129, 2)
(1312, 129, 10) <--
我想根据第一个条目总结一下.第一个条目应该是唯一的.
结果应如下所示:
(2, 127, 3)
(12156, 127, 3)
(4409, 127, 3) <- new sum = 3
(1312, 127, 23) <- new sum = 23
(12864, 128, 1)
(2664, 128, 2)
(12865, 129, …我有一张地图清单:
val list = List(
Map("id" -> "A", "value" -> 20, "name" -> "a"),
Map("id" -> "B", "value" -> 10, "name" -> "b"),
Map("id" -> "A", "value" -> 5, "name" -> "a"),
Map("id" -> "C", "value" -> 1, "name" -> "c"),
Map("id" -> "D", "value" -> 60, "name" -> "d"),
Map("id" -> "C", "value" -> 3, "name" -> "c")
)
我想要以最有效的方式对值进行求和value并按id值分组,以便它变为:
Map(A -> 25, B -> 10, C -> 4, D -> 60)
我对泛型类型感到困惑。我希望它2.asInstanceOf[A]被转换为 type A，同时，它被转换为Int. 除此之外，输入是java.lang.Long而输出是一个列表Int（根据定义，输入和输出应该是相同的类型）。这是为什么？
def whatever[A](x: A): List[A] = {
val two = 2.asInstanceOf[A]
val l = List(1.asInstanceOf[A],2.asInstanceOf[A])
println(f"Input type inside the function for 15L: ${x.getClass}")
println(f"The class of two: ${two.getClass}, the value of two: $two")
println(f"The class of the first element of l: ${l.head.getClass}, first element value: ${l.head}")
l
}
println(f"Returned from whatever function: ${whatever(15L)}")
输出：
Input type inside the function for 15L: class java.lang.Long
The class of two: class …我需要更新(检索并增加)绑定到地图中两个键的两个不同值.这两个键有时会重合.我现在有以下代码:
// val map: Map[Int, Int]
// val key1, key2: Int
if (key1 == key2) {
tailRecFunction(someArg, map
+ Tuple2(key1, 2 + map.getOrElse(key1, 0)))
} else {
tailRecFunction(someArg, map
+ Tuple2(key1, 1 + map.getOrElse(key1, 0))
+ Tuple2(key2, 1 + map.getOrElse(key2, 0)))
}
正如您所看到的,如果您使用else块时key1 == key2,则值key1 == key2将会错误地增加1而不是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> …可能重复:
合并两个映射并将相同键的值相加的最佳方法是什么？
我有一堆类型的地图Map[String, Int].我希望能够在键对应时将它们合并为值.例如,++地图上的标准方法给出了
Map("a" -> 1, "b" -> 2) ++ Map("a" -> 3, "c" -> 5)
// Map[String,Int] = Map(a -> 3, b -> 2, c -> 5)
我想定义一个结果会给出的操作
Map("a" -> 1, "b" -> 2) ?? Map("a" -> 3, "c" -> 5)
// Map[String,Int] = Map(a -> 4, b -> 2, c -> 5)
在花哨的措辞中,Map[A, B]总是具有幺半群的自然结构,但是当B它本身就是幺半群时有一个不同的结构.
现在,编写一个递归实现并不困难LinkedHashMap,但我认为必须有一些简单而更通用的方法来编写它,可能使用scalaz.有任何想法吗？
根据这个问题:
我需要使用scalaz来获得我想要的东西,但是我很好奇,如果有人知道为什么以下不能像我期望的那样工作？
Map(1->2.0)+(1->1.0) //Map(1->1.0)
我希望这会导致 Map(1->3.0).但是,似乎地图只返回最后一个键,如下所示:
Map(1->1.0, 1->3.0) //Map(1->3.0)
所以,基于文档
向此集合添加两个或多个元素并返回一个新集合.
以上,我的猜测是地图可能存储值,但只返回最后一项？这不是我对添加应该做什么的直觉......也许这是一种效率举措.
一旦我有更多的时间,我会看一下代码并尝试从那里弄清楚,但是想问这里,以防有人已经知道了？