小编Las*_*asf的帖子

有了这段代码

val foo = List('a', 'b', 'c')
aString.forall(foo.contains(_))

IntelliJ突出显示foo.contains(_)并建议"匿名函数可转换为方法值".我研究过eta扩展,但我无法看到如何改进这段特殊的代码.有任何想法吗？

在Play 2.3中,我有一个带有一个可选双成员的case类:

case class SomeClass(foo: Option[Double])

我需要一个JSON写入转换器,将成员处理为可空:

implicit val someClassWrite: Writes[SomeClass] = ???

在播放文档提供了一个例子:

case class DisplayName(name:String)
implicit val displayNameWrite: Writes[DisplayName] = Writes {
  (displayName: DisplayName) => JsString(displayName.name)
}

但遗憾的是我无法弄清楚如何做到这一点1)单个可空和2)双.有任何想法吗？谢谢.

更新#1:我能想出的唯一解决方案是:

implicit val someClassWrite: Writes[SomeClass] = Writes {
  (someClass: SomeClass) => someClass.foo match {
    case Some(f) => JsNumber(BigDecimal(f))
    case _ => JsNull
}

更新#2:忽略我的解决方案.Travis Brown就是其中之一.

在以下示例中（scala 2.11和play-json 2.13）

val j ="""{"t":2.2599999999999997868371792719699442386627197265625}"""
println((Json.parse(j) \ "t").as[BigDecimal].compare(BigDecimal("2.2599999999999997868371792719699442386627197265625")))

输出为-1。他们不应该平等吗？在打印解析的值时，它会打印四舍五入的值：

println((Json.parse(j) \ "t").as[BigDecimal]) 给 259999999999999786837179271969944

我有一个很难理解什么是硬件支持的synchronized声明和相关的notify(),notifyAll()和wait()方法,目前所有的Java对象.

我已阅读并知道如何使用此构造,但我一直认为它们直接映射到硬件基元.

当我进一步深入研究有关并发性的书籍时,我只阅读了由硬件直接提供的比较和交换(CAS)操作.

似乎这些构造是由JVM本身创建/维护的.如果我的读数正确,则每个对象都包含一些状态,其中包含有关访问它的线程的信息.这用于定义该对象的监视器并协调多个线程对该对象的访问.
但如果是这种情况,这个状态本身如何通过并发访问来管理？它一定要管理,对吗？是CAS吗？

如果是CAS,那意味着只有一种真正的同步形式CAS.所有其他都是衍生品.那么,为什么是这台显示器构建与关联synchronized,notify(),notifyAll(),wait()开发给出的方法是,原子变量(即CAS)是在性能方面更好,也无等待？

我知道用户类的原子变量只出现在Java 5.0之后,但在此之前,Java已经监视/内部锁.他们是如何实施的？

我可以使用Zipped函数进行像 sum 这样的元素操作。让我有两个列表L1和L2，如下所示

val L1 = List(1,2,3,4)
val L2 = List(5,6,7,8)

我可以按以下方式计算元素总和

(L1,L2).zipped.map(_+_)

结果是

List(6, 8, 10, 12) 

正如预期的那样。

我在我的实际代码中使用Zipped函数，但它需要太多时间。实际上，我的列表大小超过1000，我有超过1000 个列表，我的算法是迭代的，迭代次数可能高达10 亿。

在代码中，我必须做以下事情

list =( (L1,L2).zipped.map(_+_).map (_  * math.random) , L3).zipped.map(_+_)

的尺寸L1，L2和L3是相同的。此外，我必须在集群上执行我的实际代码。

在 Scala 中对 List 进行元素求和的最快方法是什么？

我有一个有几个孩子的Akka父母演员.当重新启动父actor时,我需要它来简单地停止它的子节点,而不是停止并重新创建或重新启动它们.(如果需要,将在以后手动创建一个孩子.)有没有办法做到这一点？也许以preRestart某种方式覆盖父母的方法？

Set 在其type参数中是不变的，因此显然这是行不通的：

val set: Set[Any] = Set[Int](1, 2, 3)

但是，为什么这样做有效？

val set: Set[Any] = Set[Int](1, 2, 3).map(identity)

有人可以解释吗？谢谢

这不会编译：

class MyClass[+A] {
  def myMethod(a: A): A = a
}
//error: covariant type A occurs in contravariant position in type A of value a

好吧，很公平。但这确实可以编译：

class MyClass[+A]

implicit class MyImplicitClass[A](mc: MyClass[A]) {
  def myMethod(a: A): A = a
}

这使我们能够规避方差检查给我们带来的任何问题：

class MyClass[+A] {
  def myMethod[B >: A](b: B): B = b  //B >: A => B
}

implicit class MyImplicitClass[A](mc: MyClass[A]) {
  def myExtensionMethod(a: A): A = mc.myMethod(a)  //A => A!!
}

val foo = new MyClass[String]
//foo: MyClass[String] …

我觉得这是一个愚蠢的问题,但无论如何我都会问......我正在尝试这样做:

def func(x: Int, y: Int) = {
  val value: Int = 0 //from config
  (x, y) match {
    case (value, value) => "foo"
    case _ => "bar"
  }
}

但是repl和intelliJ都警告我.(例如"变量模式后的模式不匹配"​​;"可变模式的可疑模糊"等).是否有正确的方法来匹配非文字值？

这可能是一个愚蠢的问题,但我已经有一段时间不确定了.让我们假设这遍历我的列表三次:

def doSomething(list: List[Int]): List[Int] =
  list.map(...).flatMap(...).map(...)

如果我改为:

def doSomething(list: List[Int]): List[Int] =
  list.toStream.map(...).flatMap(...).map(...).toList

我保证一次迭代吗？