使用JavaConversion在java和scala集合之间进行隐式转换

我使用一个通用函数合并了scala

Map

s的scala

Set

def mergeMaps[A, B](ms: Set[Map[A, B]])(f: (B, B) => B): Map[A, B] =
(Map[A, B]() /: (for (m <- ms; kv <- m) yield kv))
{
  (a, kv) =>
  a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv)
}

然而，它说存在类型不匹配

Error:(67, 11) type mismatch;
found   : scala.collection.mutable.Map[A,B]
required: java.util.HashMap[A,B]
    a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv)
      ^

---

JavaConversions

是否用于将

util.HashMap

隐式转换为

mutable.Map

？我在这里遗漏了什么？

一个

JavaConverter

会做你想要的吗

scala> import scala.collection.JavaConverters._
import scala.collection.JavaConverters._

scala> val x = (new java.util.HashMap[Int,Int]).asScala
x: scala.collection.mutable.Map[Int,Int] = Map()

---

他们说要尝试JavaConversions，因为JavaConversions是不受欢迎的

scala> import collection.JavaConverters._
import collection.JavaConverters._

scala> def mergeMaps[A, B](ms: Set[Map[A, B]])(f: (B, B) => B): Map[A, B] =
     | (new java.util.HashMap[A, B] /: (for (m <- ms; kv <- m) yield kv)) {
     | case (a, kv) => a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv) }
<console>:16: error: value contains is not a member of java.util.HashMap[A,B]
       case (a, kv) => a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv) }
                                  ^
<console>:16: error: java.util.HashMap[A,B] does not take parameters
       case (a, kv) => a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv) }
                                                               ^
<console>:16: error: type mismatch;
 found   : (A, B)
 required: String
       case (a, kv) => a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv) }
                                                                                    ^
<console>:15: error: type mismatch;
 found   : java.util.HashMap[A,B]
 required: Map[A,B]
       (new java.util.HashMap[A, B] /: (for (m <- ms; kv <- m) yield kv)) {
                                    ^

scala> def mergeMaps[A, B](ms: Set[Map[A, B]])(f: (B, B) => B): Map[A, B] =
     | (new java.util.HashMap[A, B].asScala /: (for (m <- ms; kv <- m) yield kv)) {
     | case (a, kv) => a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv) }
<console>:15: error: type mismatch;
 found   : scala.collection.mutable.Map[A,B]
 required: scala.collection.immutable.Map[A,B]
       (new java.util.HashMap[A, B].asScala /: (for (m <- ms; kv <- m) yield kv)) {
                                            ^

scala> def mergeMaps[A, B](ms: Set[Map[A, B]])(f: (B, B) => B): Map[A, B] =
     | (new java.util.HashMap[A, B].asScala.toMap /: (for (m <- ms; kv <- m) yield kv)) {
     | case (a, kv) => a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv) }
mergeMaps: [A, B](ms: Set[Map[A,B]])(f: (B, B) => B)Map[A,B]

scala>import collection.JavaConverters_
导入collection.JavaConverters_
scala>defmergemaps[A，B]（ms:Set[Map[A，B]]）（f：（B，B）=>B）：Map[A，B]=
|（new java.util.HashMap[A，B]/：（for（mf（A（kv._1），kv._2）else-kv）}
：16:错误：value contains不是java.util.HashMap[a，B]的成员
案例（a，kv）=>a+（如果（a.包含（kv.\u 1））kv.\u 1->f（a（kv.\u 1），kv.\u 2）其他kv）}
^
：16:错误：java.util.HashMap[A，B]不接受参数
案例（a，kv）=>a+（如果（a.包含（kv.\u 1））kv.\u 1->f（a（kv.\u 1），kv.\u 2）其他kv）}
^
：16：错误：类型不匹配；
发现：（A，B）
必需：字符串
案例（a，kv）=>a+（如果（a.包含（kv.\u 1））kv.\u 1->f（a（kv.\u 1），kv.\u 2）其他kv）}
^
：15：错误：类型不匹配；
找到：java.util.HashMap[A，B]
所需：地图[A，B]
（新java.util.HashMap[A，B]/：（for（mb）：Map[A，B]=
|（new java.util.HashMap[A，B].asScala/：（for（mf（A（kv._1），kv._2）else-kv）}
：15：错误：类型不匹配；
找到：scala.collection.mutable.Map[A，B]
必需：scala.collection.immutable.Map[A，B]
（new java.util.HashMap[A，B].asScala/：（for（mb）：Map[A，B]=
|（new java.util.HashMap[A，B].asScala.toMap/：（for（mf（A（kv._1），kv._2）else-kv）}
合并映射：[A，B]（ms:Set[Map[A，B]]）（f：（B，B）=>B）映射[A，B]

也许是为了说明为什么不推荐它：

scala> def mergeMaps[A, B](ms: Set[Map[A, B]])(f: (B, B) => B): Map[A, B] =
     | (new java.util.HashMap[A, B] /: (for (m <- ms; kv <- m) yield kv)) {
     | case (a, kv) => a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv) }
<console>:19: error: type mismatch;
 found   : scala.collection.mutable.Map[A,B]
 required: java.util.HashMap[A,B]
       case (a, kv) => a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv) }
                         ^
<console>:18: error: type mismatch;
 found   : java.util.HashMap[A,B]
 required: Map[A,B]
       (new java.util.HashMap[A, B] /: (for (m <- ms; kv <- m) yield kv)) {
                                    ^

scala>defmergemaps[A，B]（ms:Set[Map[A，B]]）（f：（B，B）=>B）：Map[A，B]=
|（new java.util.HashMap[A，B]/：（for（mf（A（kv._1），kv._2）else-kv）}
：19：错误：类型不匹配；
找到：scala.collection.mutable.Map[A，B]
必需：java.util.HashMap[A，B]
案例（a，kv）=>a+（如果（a.包含（kv.\u 1））kv.\u 1->f（a（kv.\u 1），kv.\u 2）其他kv）}
^
：18：错误：类型不匹配；
找到：java.util.HashMap[A，B]
所需：地图[A，B]
（new java.util.HashMap[A，B]/：（for（mb）=for（mb）（m def mergeMaps[A，B]（ms:Set[Map[A，B]]）（f：（B，B）=>B）：Map[A，B]={
|val ss=对于（mf（a（kv._1），kv._2）或其他kv）}
| }

已弃用？我在或上都没有发现任何提及。我的优势在于我最近参与了弃用：@jwvh我记得文档中也有一点改进，因为大多数改进都是增量的：另外，不要被新的scaladoc页面样式完全吹走。嗯，我不认为“吹走了”这是我如何描述我的反应，但我对你的见解印象深刻。谢谢分享。@jwvh先生，你能帮我吗

scala> def mergeMaps[A, B](ms: Set[Map[A, B]])(f: (B, B) => B): Map[A, B] =
     | (new java.util.HashMap[A, B] /: (for (m <- ms; kv <- m) yield kv)) {
     | case (a, kv) => a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv) }
<console>:19: error: type mismatch;
 found   : scala.collection.mutable.Map[A,B]
 required: java.util.HashMap[A,B]
       case (a, kv) => a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv) }
                         ^
<console>:18: error: type mismatch;
 found   : java.util.HashMap[A,B]
 required: Map[A,B]
       (new java.util.HashMap[A, B] /: (for (m <- ms; kv <- m) yield kv)) {
                                    ^

scala> def mergeMaps[A, B](ms: Set[Map[A, B]])(f: (B, B) => B) = for (m <- ms; kv <- m) yield kv
mergeMaps: [A, B](ms: Set[Map[A,B]])(f: (B, B) => B)scala.collection.immutable.Set[(A, B)]

scala> def mergeMaps[A, B](ms: Set[Map[A, B]])(f: (B, B) => B): Map[A, B] = {
     | val ss = for (m <- ms; kv <- m) yield kv
     | (new java.util.HashMap[A, B] /: ss) {
     | case (a, kv) => a + (if (a.contains(kv._1)) kv._1 -> f(a(kv._1), kv._2) else kv) }
     | }