什么是一个懒惰的VAL吗?

我注意到,斯卡拉提供lazy vals 。 但我不明白他们做什么。

scala> val x = 15 x: Int = 15 scala> lazy val y = 13 y: Int = <lazy> scala> x res0: Int = 15 scala> y res1: Int = 13

本REPL显示y是一个lazy val ,但它是如何从一个正常的不同val

--------------解决方案-------------

它们之间的区别是,一个val当它而一个定义在执行lazy val当被访问的第一次被执行。

scala> val x = { println("x"); 15 }
x
x: Int = 15

scala> lazy val y = { println("y"); 13 }
y: Int = <lazy>

scala> x
res2: Int = 15

scala> y
y
res3: Int = 13

scala> y
res4: Int = 13

相反的方法(与定义def )一个lazy val是一次,然后从未再次执行。 当操作需要很长的时间来完成,如果以后使用它时,它是不知道这会非常有用。

scala> class X { val x = { Thread.sleep(2000); 15 } }
defined class X

scala> class Y { lazy val y = { Thread.sleep(2000); 13 } }
defined class Y

scala> new X
res5: X = [email protected] // we have to wait two seconds to the result

scala> new Y
res6: Y = [email protected] // this appears immediately

这里,当值xy从不使用,只有x不必要地浪费资源。 如果我们假设y没有副作用,而我们不知道它的访问频率(从不,一次,上千次),这是没用的,其声明为def ,因为我们不希望执行它几次。

如果你想知道如何lazy vals的落实,见这个问题。

此功能有助于不仅延缓昂贵的计算,但是也构建相互依赖或环状结构是有用的。 例如,这将导致一个堆栈溢出:

trait Foo { val foo: Foo }
case class Fee extends Foo { val foo = Faa() }
case class Faa extends Foo { val foo = Fee() }

println(Fee().foo)
//StackOverflowException

但随着懒丘壑它工作正常

trait Foo { val foo: Foo }
case class Fee extends Foo { lazy val foo = Faa() }
case class Faa extends Foo { lazy val foo = Fee() }

println(Fee().foo)
//Faa()

lazy无循环依赖非常有用,如下面的代码:

abstract class X {
val x: String
println ("x is "+x.length)
}

object Y extends X { val x = "Hello" }
Y

访问Y现在会抛出空指针异常,因为x尚未初始化。 以下,然而,正常工作:

abstract class X {
val x: String
println ("x is "+x.length)
}

object Y extends X { lazy val x = "Hello" }
Y

编辑:下面还将努力:

object Y extends { val x = "Hello" } with X

这就是所谓的“早期初始化”。 详细信息请参见这太问题。

分类:斯卡拉 时间:2015-03-15 人气:1
本文关键词: 懒惰的评价,斯卡拉
分享到:

相关文章

Copyright (C) 55228885.com, All Rights Reserved.

55228885 版权所有 京ICP备15002868号

processed in 0.559 (s). 10 q(s)