Supposed I have a method fun()
boolean fun()
{
System.out.println("Hello World");
return true;
}
I also have a variable a
boolean a = true;
Now if I write
boolean b = a || fun();
will Java evaluate the right hand side of || or will it stop (since a is already true, so the answer is always going to be true and hence it doesn't evaluate the right hand side of ||).
See documentation from oracle:
The Conditional Operators
The && and || operators perform Conditional-AND and Conditional-OR operations on two boolean expressions.
These operators exhibit "short-circuiting" behavior, which means that the second operand is evaluated only if needed.
https://docs.oracle.com/javase/tutorial/java/nutsandbolts/op2.html
So, java will NOT evaluate the fun() expression here, since the "short-circuit" a already determines the final value.
If one needs fun() to be evaluated, a quick fix can be as following:
boolean b = fun() || a;
or
boolean funValue = fun();
boolean b = a || funValue;
Java will not evaluate the right expression.
The same goes for && in case the first expression evaluates to false.
This is required, so you can do things like:
if (a != null && !a.isEmpty()) {
//...
}
Related
Lets say I have this:
if(bool1 && bool2 && bool3) {
...
}
Now. Is Java smart enough to skip checking bool2 and bool3 if bool1 was evaluated to false? Does java even check them from left to right?
I'm asking this because i was "sorting" the conditions inside my if statements by the time it takes to do them (starting with the cheapest ones on the left). Now I'm not sure if this gives me any performance benefits because i don't know how Java handles this.
Yes, Java (similar to other mainstream languages) uses lazy evaluation short-circuiting which means it evaluates as little as possible.
This means that the following code is completely safe:
if(p != null && p.getAge() > 10)
Also, a || b never evaluates b if a evaluates to true.
Is Java smart enough to skip checking bool2 and bool2 if bool1 was evaluated to false?
Its not a matter of being smart, its a requirement specified in the language. Otherwise you couldn't write expressions like.
if(s != null && s.length() > 0)
or
if(s == null || s.length() == 0)
BTW if you use & and | it will always evaluate both sides of the expression.
Please look up the difference between & and && in Java (the same applies to | and ||).
& and | are just logical operators, while && and || are conditional logical operators, which in your example means that
if(bool1 && bool2 && bool3) {
will skip bool2 and bool3 if bool1 is false, and
if(bool1 & bool2 & bool3) {
will evaluate all conditions regardless of their values.
For example, given:
boolean foo() {
System.out.println("foo");
return true;
}
if(foo() | foo()) will print foo twice, and if(foo() || foo()) - just once.
Yes,that is called short-circuiting.
Please take a look at this wikipedia page on short-circuiting
This question already has answers here:
Does Java evaluate remaining conditions after boolean result is known?
(7 answers)
Closed 7 years ago.
Does java calculate the second condition in ( test1 || test2 ) if the first one is true ?
I use Optional and I have something like that :
if (!opt.isPresent() || opt.get() == currentPlayer.getSelectedRegion())
and there will be a problem if the first test is true and java compute the second test.
If first condition is true second condition is not evaluated.
If first condition is false also second condition is evaluated.
That's why you can write a code like the following without a NullPointerException
if (str == null || str.length() == 0) {
// do something
}
The operator | (instead of || ) will evaluated both conditions
So the code
if (str == null | str.length() == 0) {
// do something
}
can generate a NullPointerException if str is null
Does java calculate the second condition in ( test1 || test2 ) if the first one is true ?
No. Boolean or will short-circuit, the first true is sufficient to make the expression true. No further conditions will be evaluated after that.
If you use the || and &&, rather than the | and &, Java will not bother to evaluate the right-hand operand.
No, java short-cut operators, the second argument is not evaluated if the first is. Ore more formal:
for x || y, y is only evaluated if x is false; and
for x && y, x is only evaluated if y is true.
This will increase performance and can be both useful and tricky:
usefull: to prevent you from doing things such that an error is thrown. The most typical example is the null check:
if(x != null && x.someTest())
this will prevent .someTest being called if x is null.
tricky: the problematic aspect can be if you call a method that does not only return something, but changes state as well. For instance:
public class Foo {
private int checked = 0;
bool someCondition () {
return (checked % 2) == 0;
}
bool neverChecked () {
checked++;
return checked == 1;
}
}
if you now call:
if(foo.someCondition() || foo.neverChecked());
this is one of the main reasons it is adviseable to keep "getters" (thinks that calculate things of an object), and "setters" (things that modify the state of an object), clearly separated. From the moment you start mixing, one can get complicated behavior in some circumstances.
it can be the intention that you always increment checked, but it will only if .someCondition happens to be false.
When I use the OR operator, only one expression has to be true. Is the first if statement more efficient because java checks only the first expression? Or does java check both?
public class Test {
public static void main(String args[]) {
boolean test = true;
if (test || calculate()) {
// do something
}
if (calculate() || test) {
// do something
}
}
public static boolean calculate() {
// processor-intensive algorithm
}
}
if (test || calculate())
would never call calculate() when test is true, since || operator is short circuited, so that statement is more efficient when test is true.
Yes , it is . because calculate() is never called , as long as test is true and it is the contract of || statements.
From ยง15.24,
The conditional-or operator || operator is like | , but
evaluates its right-hand operand only if the value of its left-hand
operand is false.
There are two or operators:
if ( condition | condition2 ){
Here, it will test the second condition regardless of the outcome of the second condition.
if ( condition || condition2 ){
Here, the second condition will only be checked if the first condition returned false.
The same way of double operators is implemented for the 'and' operators & and &&
I'm working on an app for Android. In my code I have the following lines:
if (shape != null && !created && isTap(touchDown, event)) {
DrawPrimitive newShape = listener.onTouch(event, shape);
if (newShape != shape)
canvas.onDrawingChanged(true);
}
created is a boolean member. I'm wondering because created is true but the runtime steps into my if even without calling the isTap method. If I change the ! to the false comparsion, everything works fine.
if (shape != null && created == false && isTap(touchDown, event)) {
DrawPrimitive newShape = listener.onTouch(event, shape);
if (newShape != shape)
canvas.onDrawingChanged(true);
}
So I'm wondering if the ! is not allowed. But even if so, why is my isTap method (in version one) not called and why is the inner code executed without evaluating all AND conditions.
Why isTap() isn't called: && conjunctions (and || disjunctions for that matter) are evaluated with short-circuiting from left to right: when the left hand side operand of the expression evaluates to false (true for ||), the right hand side operand does not need to be evaluated: the value of the expression is already known.
!created and created == false are the same in Java if created is boolean. If it's Boolean, you will have problems with autoboxing/unboxing:
!created autounboxes the Boolean to boolean and complements the result with !.
created == false autoboxes false boolean literal to Boolean and compares the object references. They aren't necessarily the same Boolean objects.
To avoid such problems and as a rule of thumb, don't use true or false directly in boolean expressions.
!created and created == false are equivalent. The first version should behave in exactly the same way as the second.
Ok, i am building program to check many fields. If at least 1 field is not ok then i don't want my program to spend time to check other fields. So let look at this code:
// Util.isReadyToUse method return true if the string is ready for using, & return false if it is not.
boolean isOK=true;
if(!Util.isReadyToUse(firstName)){
isOK=false;
}
else if(isOK && !Util.isReadyToUse(lastName)){
isOK=false;
}
else if(isOK && !Util.isReadyToUse(email)){
isOK=false;
}
.....more checking
if(isOK) {
//do sthing
}
Ok, when running, the program will first check !Util.isReadyToUse(firstName). Suppose it returns (isOK=false). Next the program will check isOK && !Util.isReadyToUse(lastName).
So my question here is that Since the isOK currently false, then will the program spend time to check the condition !Util.isReadyToUse(lastName) after &&?
Ok, As a human being, if you see isOK=false and now you see isOK && !Util.isReadyToUse(email), then you don't want to waste time to look at !Util.isReadyToUse(email) since isOK=false and u saw && after isOK.
Will machine also work like that?
I am thinking to use break but why people say break doesn't work in if statement:
if(!Util.isReadyToUse(firstName)){
isOK=false;
break;
}
else if(isOK && !Util.isReadyToUse(lastName)){
isOK=false;
break;
}......
What is the best solution in this situation?
So my question here is that Since the isOK currently false, then will
the program spend time to check the condition
!Util.isReadyToUse(lastName) after &&?
Java is smart, if you have a condition if(somethingFlase && something), then something won't be reached due to Short-circuit evaluation. Since the whole expression will be false regardless of the second condition, there is no need for Java to evaluate that.
From 15.23. Conditional-And Operator &&:
If the resulting value is false, the value of the conditional-and
expression is false and the right-hand operand expression is not
evaluated. If the value of the left-hand operand is true, then the right-hand expression is evaluated.
if(a && b) - if a is false, b won't be checked.
if(a && b) - if a is true, b will be checked, because if it's false, the expression will be false.
if(a || b) - if a is true, b won't be checked, because this is true anyway.
if(a || b) - if a is false, b will be checked, because if b is true then it'll be true.
No, it shortcuts the rest of the predicate.
That's you'll see things like
if(A != null && A.SomeVal == someOtherVal)
Java supports what is referred to as Short-Circuit Evaluation. See this page:
http://en.wikipedia.org/wiki/Short-circuit_evaluation
What this means is that if the first boolean in your statement is enough to satisfy the statement, then the rest of the values are skipped. If we have the following:
boolean a = false;
boolean b = true;
if(a && b) /*Do something*/;
'b' will never be checked, because the false value for 'a' was enough to break out of the if statement.
That being said, your program will never take advantage of this because the only time isOK is set to false is within one of your else if statements.
As the other responders mentioned Java will do the smart thing.
But it could be the case that you want Java to continue to check, in that case you can use & vs && or | vs ||.
if (someMethod() | anotherMethod() {
If the first method reutrns true, Java will still execute the second method.
if (someMethod() & anotherMethod() {
If the first method is false, Java will still execute the second method.
No, Java won't "waste time" for it. It's called short circuit evaluation.
This mechanism is commonly used e.g. for null checking :
if (foo != null && foo.neverFailsWithNPE()) {
// ...
}
You don't need to use break on an if..else if.. else statement because once it finds a condition which is true the rest aren't even looked at.