blocks|key|5380759|text|如果|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5380760|+()返回true，会调用isATrue()吗？|blockquote|5380761|5380762|5380763|是的，这两个都叫。|5380764|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|M|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|J|$]]

<blockquote>
 Is isATrue() called if isBTrue() returns true?
</blockquote>

Yes, both are called.

blocks|key|778959|text|不，它不是。无论isATrue()的结果如何，都将调用isBTrue()。您可以通过编写这样的程序来验证这一点，并在每个方法中使用print语句。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|778960|entityMap^0|8|9|R|9|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

No, it does not. <code>isBTrue()</code> will be invoked, regardless of the result of <code>isATrue()</code>. You can verify this yourself by writing such a program, with print statements in each of the methods.

blocks|key|5380881|text|嗯，就语言而言--是的，两个函数都被调用了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5380882|如果您将该函数重写为：|5380883|public+boolean+isTrue()+{
++++return+isBTrue()+%7C%7C+isATrue();
}|code-block|syntax|javascript|5380884|如果第一个函数为真，则不会调用第二个函数。|5380885|5380886|但这是短路评估，而不是懒惰评估。懒惰的评估案例看起来像这样：|5380887|public+interface+LazyBoolean+{
++++boolean+eval();
}

class+CostlyComparison+implements+LazyBoolean+{
++private+int+a,+b;

++public+CostlyComparison(int+a,+int+b)+{+
++++this.a=a;+
++++this.b=b;+
++}

++@Override+
++public+boolean+eval()+{
++++//lots+of+probably+not-always-necessary+computation+here
++++return+a+>+b;
++}
}+

public+LazyBoolean+isATrue()+{
++return+new+CostlyComparison(10,30);++//just+an+example
}

public+boolean+isTrue()+{++++++++//+so+now+we+only+pay+for+creation+of+2+objects
++++LazyBoolean+a+=+isATrue();+++//+but+the+computation+is+not+performed;+
++++LazyBoolean+b+=+isBTrue();+++//+instead,+it's+encapsulated+in+a+LazyBoolean
++++return+b.eval()+%7C%7C+a.eval();+//+and+will+be+evaluated+on+demand;
+++++++++++++++++++++++++++++++++//+this+is+the+definition+of+lazy+eval.
}|5380888|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|U|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|W|8|@]|9|@]|A|$]]|$1|N|3|O|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|P|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|Q|$]]

Well, as far as the language is concerned - yes, both functions are called.

If you rewrote the function to this:

<pre><code>public boolean isTrue() {
 return isBTrue() || isATrue();
}
</code></pre>

then the second function will not be called, if the first is true.

<hr>

But this is short-circuit evaluation, not lazy evaluation. Lazy evaluation case would look something like this:

<pre><code>public interface LazyBoolean {
 boolean eval();
}

class CostlyComparison implements LazyBoolean {
 private int a, b;

 public CostlyComparison(int a, int b) { 
 this.a=a; 
 this.b=b; 
 }

 @Override 
 public boolean eval() {
 //lots of probably not-always-necessary computation here
 return a &gt; b;
 }
} 

public LazyBoolean isATrue() {
 return new CostlyComparison(10,30); //just an example
}

public boolean isTrue() { // so now we only pay for creation of 2 objects
 LazyBoolean a = isATrue(); // but the computation is not performed; 
 LazyBoolean b = isBTrue(); // instead, it's encapsulated in a LazyBoolean
 return b.eval() || a.eval(); // and will be evaluated on demand;
 // this is the definition of lazy eval.
}
</code></pre>

blocks|key|779012|text|是，将调用isATrue()，因为您在boolean+a+=+isATrue();行中显式调用了它|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|779013|但在以下情况下，如果isBTrue()返回true，则不会调用它|779014|public+boolean+isTrue()+{
++++return+isBTrue()+%7C%7C+isATrue();
}|code-block|syntax|javascript|779015|entityMap^0|5|9|J|M|0|A|9|L|4|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

Yes <code>isATrue()</code> will be called because you are calling it explicitly in line <code>boolean a = isATrue();</code>

But it won't be called in following case if <code>isBTrue()</code> returns <code>true</code>:

<pre><code>public boolean isTrue() {
 return isBTrue() || isATrue();
}
</code></pre>

blocks|key|776717|text|不，Java只对用户定义的方法进行急切的评估。正如您所注意到的，Java的一些语言构造实现了非严格计算。其他包括if，?:，while。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|776718|我曾经在learned1上说过，对于“有懒惰的评估”的含义有一些困惑。首先，惰性评估意味着按需调用评估。Java根本没有这样的东西。然而，有一个共同的趋势(我个人不鼓励)是放松懒惰评估的定义，以包括按名称调用的评估。在按需要调用和按名称调用的评估下，不能区分诸如&&之类的函数；无论如何，它都是一样的，这就掩盖了问题。|776719|考虑到这种松散，一些人进一步反驳说，Java有以下懒惰的评估：|776720|interface+Thunk<A>+{
++A+value();
}|code-block|syntax|javascript|776721|然后，您可以编写用户定义的&&，如下所示：|776722|boolean+and(boolean+p,+Thunk<Boolean>+q)+{
++return+p+&&+q();
}|776723|然后提出声明，这表明Java具有惰性评估。然而，即使是在松散的意义上，这也不是懒惰的评估。这里的不同之处在于，Java的类型系统没有统一boolean/Boolean和Thunk<Boolean>类型。试图使用一个作为另一个将导致类型错误。在没有静态类型系统的情况下，代码仍然会失败。正是缺乏统一性(静态类型或非静态类型)回答了这个问题；不，Java没有用户定义的惰性计算。当然，它可以像上面那样被模拟，但这是从图灵等价中得出的一个无趣的观察结果。|776724|诸如Scala之类的语言具有按名称调用的计算，它允许用户定义的and函数相当于常规的&&函数(考虑到终止。请参见1)。|776725|//+note+the+=>+annotation+on+the+second+argument
def+and(p:+Boolean,+q:+=>+Boolean)+=
++p+&&+q|776726|这允许：|776727|def+z:+Boolean+=+z
val+r:+Boolean+=+and(false,+z)|776728|请注意，这个简短的程序片段通过提供一个值来终止。它还将Boolean类型的值统一为call-by-name。因此，如果您赞同延迟计算的松散定义(同样，我不鼓励这样做)，您可能会说Scala有延迟计算。我在这里提供Scala作为一个很好的对比。我推荐使用Haskell进行真正的惰性评估(call-by-need)。|776729|希望这能有所帮助！|776730|1|776731|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.tmorris.net/posts/a-fling-with-lazy-evaluation/^0|1K|2|1N|2|1Q|5|0|3N|2|0|0|0|D|2|0|0|1W|7|24|7|2C|E|0|V|3|16|2|0|0|0|0|R|7|0|0|0|1|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1R|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1V|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1W|8|@$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]|$9|21|A|22|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|23|8|@$9|24|A|25|B|C]|$9|26|A|27|B|C]]|D|@]|E|$]]|$1|W|3|X|5|L|7|28|8|@]|D|@]|E|$M|N]]|$1|Y|3|Z|5|6|7|29|8|@]|D|@]|E|$]]|$1|10|3|11|5|L|7|2A|8|@]|D|@]|E|$M|N]]|$1|12|3|13|5|6|7|2B|8|@$9|2C|A|2D|B|C]]|D|@]|E|$]]|$1|14|3|15|5|6|7|2E|8|@]|D|@]|E|$]]|$1|16|3|17|5|6|7|2F|8|@]|D|@$9|2G|A|2H|1|2I]]|E|$]]|$1|18|3|-4|5|6|7|2J|8|@]|D|@]|E|$]]]|19|$1A|$5|1B|1C|1D|E|$1E|1F]]]]

No, Java has only eager evaluation for user-defined methods. Some of Java's language constructs implement non-strict evaluation as you note. Others include <code>if</code>, <code>?:</code>, <code>while</code>.

I once learned[1] that there is some confusion around what it means to "have lazy evaluation." First, lazy evaluation means call-by-need evaluation. Java has nothing at all like this. However, there is a common trend (which I personally discourage) to loosen the definition of lazy evaluation to also include call-by-name evaluation. Functions such as <code>&amp;&amp;</code> cannot be distinguished under call-by-need versus call-by-name evaluation; it would be the same regardless, which obscures the matter.

Taking this loosening into account, some further counter-argue by claiming Java has lazy evaluation by the following:

<pre><code>interface Thunk&lt;A&gt; {
 A value();
}
</code></pre>

Then, you might write a user-defined <code>&amp;&amp;</code> like so:

<pre><code>boolean and(boolean p, Thunk&lt;Boolean&gt; q) {
 return p &amp;&amp; q();
}
</code></pre>

The claim is then put forward that this demonstrates that Java has lazy evaluation. However, this is not lazy evaluation, even in the loose sense. The distinguishing point here is that Java's type system does not unify the types <code>boolean</code>/<code>Boolean</code> and <code>Thunk&lt;Boolean&gt;</code>. Attempting to use one as the other will result in a type-error. In the absence of a static type system, the code would still fail. It is this lack of unification (static typing or not) that answers the question; no, Java does not have user-defined lazy evaluation. Of course, it can be emulated as above, but this is an uninteresting observation which follows from turing-equivalence.

A language such as Scala has call-by-name evaluation, which allows a user-defined <code>and</code> function which is equivalent to the regular <code>&amp;&amp;</code> function (taking termination into account. See [1]).

<pre><code>// note the =&gt; annotation on the second argument
def and(p: Boolean, q: =&gt; Boolean) =
 p &amp;&amp; q
</code></pre>

This allows:

<pre><code>def z: Boolean = z
val r: Boolean = and(false, z)
</code></pre>

Note that this short program snippet terminates by providing a value. It also unifies values of type <code>Boolean</code> as call-by-name. Therefore, if you subscribe to the loose definition of lazy evaluation (and again, I discourage this), you might say that Scala has lazy evaluation. I provide Scala here as a good contrast. I recommend looking at Haskell for true lazy evaluation (call-by-need).

Hope this helps!

[1] <a href="http://blog.tmorris.net/posts/a-fling-with-lazy-evaluation/" rel="noreferrer">http://blog.tmorris.net/posts/a-fling-with-lazy-evaluation/</a>

blocks|key|2029086|text|SE8+(JDK1.8)引入了Lambda+expressions，它可以使惰性评估更加透明。考虑以下代码的main方法中的语句：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2029087|@FunctionalInterface
public+interface+Lazy<T>+{
+++T+value();
}

class+Test+{
+++private+String+veryLongMethod()+{
++++++//Very+long+computation
++++++return+"";
+++}

+++public+static+<T>+T+coalesce(T+primary,+Lazy<T>+secondary)+{
++++++return+primary+!=+null?+primary+:+secondary.value();
+++}

+++public+static+void+main(String[]+argv)+{
++++++String+result+=+coalesce(argv[0],+()->veryLongMethod());
+++}
}|code-block|syntax|javascript|2029088|调用的函数coalesce返回第一个给定的非空值(就像在SQL中一样)。其调用中的第二个参数是一个Lambda表达式。只有当argv+==为空时，才会调用veryLongMethod()方法。在这种情况下，惟一的有效负载是在按需延迟计算的值之前插入()->。|style|CODE|2029089|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html^0|F|I|0|0|0|3G|4|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

SE8 (JDK1.8) has introduced <a href="http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html">Lambda expressions</a>, which can make lazy evaluations more transparent. Consider the statement in the main method of the following code:

<pre><code>@FunctionalInterface
public interface Lazy&lt;T&gt; {
 T value();
}

class Test {
 private String veryLongMethod() {
 //Very long computation
 return "";
 }

 public static &lt;T&gt; T coalesce(T primary, Lazy&lt;T&gt; secondary) {
 return primary != null? primary : secondary.value();
 }

 public static void main(String[] argv) {
 String result = coalesce(argv[0], ()-&gt;veryLongMethod());
 }
}
</code></pre>

The called function coalesce returns the first given non-null value (as in SQL). The second parameter in its call is a Lambda expression. The method veryLongMethod() will be called only when argv[0] == null. The only payload in this case is inserting <code>()-&gt;</code> before the value to be lazily evaluated on demand.

blocks|key|5381051|text|为简单起见，您可以使用java+8中的Supplier接口，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5381052|Supplier<SomeVal>+someValSupplier+=+()+->+getSomeValLazily();|code-block|syntax|javascript|5381053|然后，在之后的代码中，您可以拥有：|5381054|if+(iAmLazy)+
++someVal+=+someValSupplier.get();+//+lazy+getting+the+value
else+
++someVal+=+getSomeVal();+//+non+lazy+getting+the+value|5381055|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

For simplicity you can use the Supplier interface from java 8 like this:

<pre><code>Supplier&lt;SomeVal&gt; someValSupplier = () -&gt; getSomeValLazily();
</code></pre>

Then in code afterwards you can have:

<pre><code>if (iAmLazy) 
 someVal = someValSupplier.get(); // lazy getting the value
else 
 someVal = getSomeVal(); // non lazy getting the value
</code></pre>

blocks|key|5863417|text|除了这个问题帖子中提到的内容之外，我还想补充一下，下面是关于JVM的Oracle文档|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5863418|5863419|+Java+Virtual+Machine实现可以选择在使用时单独解析类或接口中的每个符号引用(“惰性”或“延迟”解析)，或者在验证类时一次性解析它们(“急切”或“静态”解析)。这意味着在一些实现中，在类或接口已经被初始化之后，解析过程可以继续。|blockquote|5863420|5863421|5863422|reference|offset|length|5863423|作为具有延迟实现的类的一个示例是Stream，这来自Oracle关于Stream的文档|5863424|5863425|流是惰性的；仅在发起终端操作时才执行源数据上的计算，并且仅在需要时才使用源元素。|5863426|5863427|5863428|5863429|也就是说，如果您执行以下操作，则不会显示任何内容。除非您添加启动器。|5863430|Steam.of(1,+2,+3,+4,+5).filter(number+->+{
+++System.out.println("This+is+not+going+to+be+logged");
+++return+true;
});|code-block|syntax|javascript|5863431|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-5.html|1|https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html^0|0|0|0|0|0|0|9|0|0|0|0|0|0|0|0|9|1|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1C|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1F|8|@]|9|@$J|1G|K|1H|1|1I]]|A|$]]|$1|L|3|M|5|6|7|1J|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|O|3|P|5|E|7|1L|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|S|3|I|5|6|7|1O|8|@]|9|@$J|1P|K|1Q|1|1R]]|A|$]]|$1|T|3|U|5|6|7|1S|8|@]|9|@]|A|$]]|$1|V|3|W|5|X|7|1T|8|@]|9|@]|A|$Y|Z]]|$1|10|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]|18|$5|13|14|15|A|$16|19]]]]

Just wanted to add in addition to what have been mentioned in this question thread, below is from Oracle Documentation on JVM

<blockquote>
 a Java Virtual Machine implementation may choose to resolve each
 symbolic reference in a class or interface individually when it is
 used ("lazy" or "late" resolution), or to resolve them all at once
 when the class is being verified ("eager" or "static" resolution).
 This means that the resolution process may continue, in some
 implementations, after a class or interface has been initialized.
</blockquote>

<a href="https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-5.html" rel="nofollow noreferrer">reference</a>

and as an example of the classes that has lazy implementation is Stream, this is from Oracle Documentation on Stream

<blockquote>
 Streams are lazy; computation on the source data is only performed
 when the terminal operation is initiated, and source elements are
 consumed only as needed.
</blockquote>

<a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html" rel="nofollow noreferrer">reference</a>

That being said, if you do the following, nothing will be displayed. Unless you add initiator.

<pre><code>Steam.of(1, 2, 3, 4, 5).filter(number -&gt; {
 System.out.println("This is not going to be logged");
 return true;
});
</code></pre>

I know that Java has smart/lazy evaluation in this case:

<pre><code>public boolean isTrue() {
 boolean a = false;
 boolean b = true;
 return b || (a &amp;&amp; b); // (a &amp;&amp; b) is not evaluated since b is true
}
</code></pre>

But what about:

<pre><code>public boolean isTrue() {
 boolean a = isATrue();
 boolean b = isBTrue();
 return b || a;
}
</code></pre>

Is <code>isATrue()</code> called even if <code>isBTrue()</code> returns true?

Does Java have lazy evaluation?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我知道Java在这种情况下有智能/懒惰的评估：public boolean isTrue() {    boolean a = false;    boolean b = true;    return b || (a && b); // (a && b) is not evaluated since b is tru...

问Java有惰性计算吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java有惰性计算吗？EN