entityMap|blocks|key|au1oi|text|使用if/else而不是match语句进行布尔检查：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|82gfe|def+parseMetrics(metric:+Metric)+=+{
++++import+scala.collection.JavaConverters._
++++metric.transactionMap.asScala.values.map+{
++++++x+=>+if+(x)+"Y"+else+"N"
++++}.toList|code-block|syntax|javascript|a480d|我怀疑在if语句中，java.lang.Boolean+(我假设x在这里)可以通过import+scala.collection.JavaConverters._强制转换为Boolean……但是match语句不做同样的强制，但必须显式地进行(或者匹配java.lang.Boolean值)。|offset|length|style|CODE|cumbr^0|0|0|A|H|W|1|15|14|2E|7|3H|H|0^^$0|$]|1|@$2|3|4|5|6|7|8|O|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|P|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|Q|9|@$J|R|K|S|L|M]|$J|T|K|U|L|M]|$J|V|K|W|L|M]|$J|X|K|Y|L|M]|$J|Z|K|10|L|M]]|A|@]|B|$]]|$2|N|4|-4|6|7|8|11|9|@]|A|@]|B|$]]]]

Use if/else rather than a match statement for Boolean checking:

<pre class="lang-scala prettyprint-override"><code>def parseMetrics(metric: Metric) = {
 import scala.collection.JavaConverters._
 metric.transactionMap.asScala.values.map {
 x =&gt; if (x) "Y" else "N"
 }.toList
</code></pre>

My suspicion is that within the if statement the <code>java.lang.Boolean</code> (which I presume <code>x</code> is here) can be coerced to <code>Boolean</code> via <code>import scala.collection.JavaConverters._</code>... but the match statement doesn't do the same coercion, but would have to be made explicitly (or match on the <code>java.lang.Boolean</code> values).

entityMap|blocks|key|bq94l|text|另一个答案提供了一种合理的方法来解决这个问题，但没有说明为什么会遇到这个问题，或者它提出的方法是如何工作的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|12suc|Scala标准库确实提供了从java.lang.Boolean到scala.Boolean的隐式转换，您可以通过在REPL中使用reify在需要Scala+boolean的上下文中对一些使用Java+boolean的代码进行去粘合，从而看到这一点：|offset|length|style|CODE|cca20|scala>+val+x:+java.lang.Boolean+=+true
x:+Boolean+=+true

scala>+import+scala.reflect.runtime.universe.reify
import+scala.reflect.runtime.universe.reify

scala>+reify(if+(x)+1+else+0)
res0:+reflect.runtime.universe.Expr[Int]+=
Expr[Int](if+(Predef.Boolean2boolean($read.x))
++1
else
++0)|code-block|syntax|javascript|3jaah|问题是，简单地尝试将java.lang.Boolean值与true或false进行匹配并不足以触发转换。您可以通过定义自己的类型来检查这一点，在这些类型中，您可以确保确切地知道正在进行的转换：|auncc|scala>+case+class+Foo(i:+Int);+case+class+Bar(i:+Int)
defined+class+Foo
defined+class+Bar

scala>+implicit+def+foo2bar(foo:+Foo):+Bar+=+Bar(foo.i)
foo2bar:+(foo:+Foo)Bar

scala>+Foo(100)+match+{+case+Bar(x)+=>+x+}
<console>:17:+error:+constructor+cannot+be+instantiated+to+expected+type;
+found+++:+Bar
+required:+Foo
+++++++Foo(100)+match+{+case+Bar(x)+=>+x+}
+++++++++++++++++++++++++++++%5E|bvhto|这是一个语言设计决策。在这些场景中应用隐式转换可能是可能的，但也可能有一个很好的理由来说明它们不是这样的(在我看来，我不熟悉任何相关的讨论或问题，但这并不意味着它们不存在)。|ffjr3|Andy的解决方案之所以有效，是因为java.lang.Boolean处于编译器期望scala.Boolean+(条件)并愿意应用Predef.Boolean2boolean转换的位置。如果您确实想这样做，您可以手动执行此操作：|9sg8b|def+parseMetrics(metric:+Metric)+=+{
++import+scala.collection.JavaConverters._
++metric.transactionMap.asScala.values.map(Predef.Boolean2boolean).map+{
++++case+false+=>+"N"+
++++case+true+=>+"Y"
++}.toList
}|6jilm|…但至少在我看来，Boolean上的模式匹配比使用条件匹配要笨拙一点。|9lnai^0|0|E|H|W|D|1S|5|0|0|A|H|T|4|Y|5|0|0|0|I|H|16|D|1T|M|0|0|9|7|0^^$0|$]|1|@$2|3|4|5|6|7|8|10|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|11|9|@$E|12|F|13|G|H]|$E|14|F|15|G|H]|$E|16|F|17|G|H]]|A|@]|B|$]]|$2|I|4|J|6|K|8|18|9|@]|A|@]|B|$L|M]]|$2|N|4|O|6|7|8|19|9|@$E|1A|F|1B|G|H]|$E|1C|F|1D|G|H]|$E|1E|F|1F|G|H]]|A|@]|B|$]]|$2|P|4|Q|6|K|8|1G|9|@]|A|@]|B|$L|M]]|$2|R|4|S|6|7|8|1H|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|1I|9|@$E|1J|F|1K|G|H]|$E|1L|F|1M|G|H]|$E|1N|F|1O|G|H]]|A|@]|B|$]]|$2|V|4|W|6|K|8|1P|9|@]|A|@]|B|$L|M]]|$2|X|4|Y|6|7|8|1Q|9|@$E|1R|F|1S|G|H]]|A|@]|B|$]]|$2|Z|4|-4|6|7|8|1T|9|@]|A|@]|B|$]]]]

The other answer provides a reasonable way to solve this problem, but doesn't show why you're running into it or how the approach it proposes works.

The Scala standard library does provide an implicit conversion from <code>java.lang.Boolean</code> to <code>scala.Boolean</code>, which you can see in action by using <code>reify</code> in a REPL to desugar some code that uses a Java boolean in a context where a Scala boolean is expected:

<pre><code>scala&gt; val x: java.lang.Boolean = true
x: Boolean = true

scala&gt; import scala.reflect.runtime.universe.reify
import scala.reflect.runtime.universe.reify

scala&gt; reify(if (x) 1 else 0)
res0: reflect.runtime.universe.Expr[Int] =
Expr[Int](if (Predef.Boolean2boolean($read.x))
 1
else
 0)
</code></pre>

The problem is that simply trying to match a <code>java.lang.Boolean</code> value against <code>true</code> or <code>false</code> isn't sufficient to trigger the conversion. You can check this by defining your own types where you can be sure you know exactly what conversions are in play:

<pre><code>scala&gt; case class Foo(i: Int); case class Bar(i: Int)
defined class Foo
defined class Bar

scala&gt; implicit def foo2bar(foo: Foo): Bar = Bar(foo.i)
foo2bar: (foo: Foo)Bar

scala&gt; Foo(100) match { case Bar(x) =&gt; x }
&lt;console&gt;:17: error: constructor cannot be instantiated to expected type;
 found : Bar
 required: Foo
 Foo(100) match { case Bar(x) =&gt; x }
 ^
</code></pre>

This is a language design decision. It would probably be possible to have the implicit conversions applied in these scenarios, but there's also probably a good reason that they aren't (off the top of my head I'm not familiar with any relevant discussions or issues, but that doesn't mean they don't exist).

The reason Andy's solution works is that the <code>java.lang.Boolean</code> is in a position where the compiler expects a <code>scala.Boolean</code> (a condition) and is willing to apply the <code>Predef.Boolean2boolean</code> conversion. You could do this manually if you really wanted to:

<pre><code>def parseMetrics(metric: Metric) = {
 import scala.collection.JavaConverters._
 metric.transactionMap.asScala.values.map(Predef.Boolean2boolean).map {
 case false =&gt; "N" 
 case true =&gt; "Y"
 }.toList
}
</code></pre>

…but to my eye at least pattern matching on <code>Boolean</code> is a little clunkier than using a conditional.

I wrote a method to parse Metrics data and at first faced a problem with the type of transactionMap which is a <code>java.util.Map</code>. And I solved it using JavaConverters. 

<pre><code>def parseMetrics(metric: Metric) = {
 import scala.collection.JavaConverters._
 metric.transactionMap.asScala.values.map {
 case false =&gt; "N" 
 case true =&gt; "Y"
 }.toList
</code></pre>

But after that I got an error while pattern matching true and false values: <code>pattern type is incompatible with expected type, found: Boolean, required: java.lang.Boolean</code>

As far as I understand Scala does not chain two implicit conversions. Is there a way to fix it using JavaConverters?

Scala - how to pattern match when chaining two implicit conversions?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

 我写了一个解析Metrics数据的方法，一开始遇到了一个transactionMap类型的问题，它是一个java.util.Map。我用JavaConverters解决了这个问题。 def parseMetrics(metric: Metric) = {    import scala.collection.Java...

问Scala -如何在链接两个隐式转换时进行模式匹配？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala -如何在链接两个隐式转换时进行模式匹配？EN