Evaluating a boolean expression with assignments and short circuit operators

[Daniel Clinton]

This evaluation of this code is not clear to me

boolean b1,b2,b3;
		b1=b2=b3 = false;
		
		boolean result = (b1 = true) || (b2 = true) && (b3 = true);

		System.out.printf("b1:%b  b2:%b  b3:%b", b1, b2, b3);

// Console: b1:true  b2:false  b3:false

The && has higher precedence than the ||
Is it just simply Left to Right evaluation that brings about the short circuit with only b1 assigned?

[Sergej Smoljanov]

i think it eluvated from left to right and groped expression like:

int a =1;
int b = 2;
int c = 3;
int result = a + b*c;

and like this it become:

 boolean result = (b1 = true) || (    (b2 = true) && (b3 = true)    );  

Is it just simply Left to Right evaluation that brings about the short circuit with only b1 assigned?

Yes

[Roel De Nijs]

2 things play along here:

short circuit operators: the second operand is evaluated only if needed (no valuable CPU cycles are wasted if the result is already obvious after evaluating the first operand)

operators are evaluated from left to right, except for assignment operators (which are evaluated right to left)

So this is what happens:

in order to assign a value to result the right operand ((b1 = true) || (b2 = true) && (b3 = true) is evaluated

the expression (b1 = true) || (b2 = true) && (b3 = true) is evaluated from left to right, so (b1 = true) is evaluated first and returns (obviously) true

the following operator is the short-circuit OR operator ||, because the left operand (b1 = true) is true, the result will always be true no matter what the result of the right operand (b2 = true) && (b3 = true) is, therefore it's not evaluated at all

Hope it helps!

[Sergei Zhylinski]

Hi,

But nevertheless, I don't understand... Another example:

int b = 10;
b += b *= 2; // Equivalent to: b = b + (b = b * 2);
System.out.println(b); // 30

The result of the preceeding code is 30. Assignment operators have the same precedence. We have two assignments operators, so we should execute them as per their associativity, i.e. from right to left. The first operator that is to be executed is '*='. Its result is 20. But then the other assignment operator '+=' adds 10 to 20. Why doesn't it add 20 to 20? The '*=', when have been executed first, must have been assigned a new value to the variable, mustn't it?

One more code sample:

int i = 10;
i = i + ++i; // Equivalent to: i = i + (i = i + 1)
System.out.println(i) // why 21?

[Roel De Nijs]

For both your examples the same rule applies: operators are evaluated from left to right, except for assignment operators (which are evaluated right to left)

So let's start with a really simple example:

int i = 10;

This is an assignment operator, so it's evaluated from right to left; meaning 10 is assigned to variable i.

A simple example:

int i = 10;
int j = 20;
int k = i + j;

The first 2 lines are exactly the same as the really simple example. The 3rd line is also an assignment: a value will be assigned to variable k. To know the actual value, we'll need to evaluate the right expression i + j. This expression is evaluated from left to right, so 10 + 20 is evaluated to 30 and 30 is assigned to variable k.

Now it's time to take a look at your second example:

int i = 10;  
i = i + ++i; // Equivalent to: i = i + (i = i + 1)

The 1st line is exactly the same as the really simple example. The 2nd line is similar to the 3rd line from the simple example. So in order to know which value will be assigned to i, we have to evaluate the right expression from left to right i + ++i. So here we go:

step 0: i + ++i

step 1: 10 + ++i (replace i with its current value 10)

step 2: 10 + 11 (increment actual value from i with 1, assign this value to i and use this value in the expression; this new value of i will only be used for next occurences of i, not for previous ones, because these were already evaluated)

step 3: 21 (execute the addition)

Now we know which value (21) can be assigned to variable i.

Now let's swap the 1st and 2nd operand of the assignment and see if there is a difference in the output.

int i = 10;  
i = ++i + i;

Only the steps differ from the previous example, so here we go again:

step 0: ++i + i

step 1: 11 + i (increment actual value from i with 1, assign this value to i and use this value in the expression; this new value of i will only be used for next occurences of i, not for previous ones, because these were already evaluated)

step 2: 11 + 11 (replace i with its current value 11, not 10)

step 3: 22 (execute the addition)

So 22 is assigned to variable i and the order of operands in this example does really matter!

Now let's see if you can work out your other example yourself:

int b = 10;  
b += b *= 2; // Equivalent to: b = b + (b = b * 2);

Hope it helps!

[Henry Wong]

Sergey Zhylinsky wrote:I don't understand... Another example:

int b = 10;
b += b *= 2; // Equivalent to: b = b + (b = b * 2);
System.out.println(b); // 30

The result of the preceeding code is 30. Assignment operators have the same precedence. We have two assignments operators, so we should execute them as per their associativity, i.e. from right to left. The first operator that is to be executed is '*='. Its result is 20. But then the other assignment operator '+=' adds 10 to 20. Why doesn't it add 20 to 20? The '*=', when have been executed first, must have been assigned a new value to the variable, mustn't it?

No. Order of evaluation, precedence, and associativity are three different concepts. You are right in that the precedence does not apply here, but the order of evaluation is still left to right. In other words, you have to apply the associativy from right to left, but evaluate it from left to right...

The best way to do that is ... think of this...

b += b *= 2;

as

b += (b *= 2);

Now, you have to go from left to right, but have to use temporary variables as you need to complete the right assignment first. In other words, the left assignment will actually be started first, as the evaluation is going left to right, but the right assignment would be completed first, due to right to left associativity.

Henry

[Sergei Zhylinski]

Hi,

Now I begin to understand the code:

boolean result = (b1 = true) || (b2 = true) && (b3 = true); 

The precedence of '&&' is higher than that of '||'. Therefore, it would be executed first. But order of evaluation is beyond the precedence and associativity. As the evaluation order comes from left to right, the first expression '(b1 = true)' will be evaluated first. As it is 'true' there is no need to evaluate other expressions.

[Roel De Nijs]

Sergey Zhylinsky wrote:The precedence of '&&' is higher than that of '||'. Therefore, it would be executed first. But order of evaluation is beyond the precedence and associativity. As the evaluation order comes from left to right, the first expression '(b1 = true)' will be evaluated first. As it is 'true' there is no need to evaluate other expressions.

Exactly!

Now what will the output be if || and && are swapped? What's the output of this code snippet?

boolean b1, b2, b3;
b1 = b2 = b3 = false;
boolean result = (b1 = true) && (b2 = true) || (b3 = true);
System.out.printf("b1:%b  b2:%b  b3:%b result:%b%n", b1, b2, b3, result);

[Sergei Zhylinski]

Roel De Nijs wrote:

Sergey Zhylinsky wrote:The precedence of '&&' is higher than that of '||'. Therefore, it would be executed first. But order of evaluation is beyond the precedence and associativity. As the evaluation order comes from left to right, the first expression '(b1 = true)' will be evaluated first. As it is 'true' there is no need to evaluate other expressions.

Exactly!

Now what will the output be if || and && are swapped? What's the output of this code snippet?

boolean b1, b2, b3;
b1 = b2 = b3 = false;
boolean result = (b1 = true) && (b2 = true) || (b3 = true);
System.out.printf("b1:%b  b2:%b  b3:%b result:%b%n", b1, b2, b3, result);

So the expression

result = (b1 = true) && (b2 = true) || (b3 = true)

Can be explicitely decomposed into subexpressions by providing parentheses as per operators' precedence and associativity:

result = ((b1 = true) && (b2 = true)) || (b3 = true)

Hence, there are two general subexpressions:

((b1 = true) && (b2 = true))

and

(b3 = true)

The evaluation begins from left to right, so the first expression that is to be evaluated is:

((b1 = true) && (b2 = true))

The 'b1' and 'b2' vars will be assigned to 'true'.

As this expression equals to 'true', and the operator '||' is short-circuit, there is no need to evaluate the second expression:

(b3 = true)

So the result would be: b1:true b2:true b3:false result:true

[Roel De Nijs]

Sergey Zhylinsky wrote:So the result would be: b1:true b2:true b3:false result:true

You are spot-on!

[Tony Singarayar]

Hi,
I have a doubt in sergei's last reply...

    boolean b1, b2, b3;  
    b1 = b2 = b3 = false;  
    boolean result = (b1 = true) && (b2 = true) || (b3 = true);  
    System.out.printf("b1:%b  b2:%b  b3:%b result:%b%n", b1, b2, b3, result);

Wouldn't line 3 be evaluated as per below.
1.(b1 = true) &&( (b2 = true) || (b3 = true))
OR
2.((b1 = true) && (b2 = true)) || (b3 = true); //as sergei mentioned...
In both the cases answer is true thou.
Thanks,
Tony Singarayar

[Roel De Nijs]

Tony Singarayar wrote:Wouldn't line 3 be evaluated as per below.
1.(b1 = true) &&( (b2 = true) || (b3 = true))
OR
2.((b1 = true) && (b2 = true)) || (b3 = true); //as sergei mentioned...

This example shows that when you use both && and || operators in 1 statement you should use parantheses to increase readibility & maintainability. But that advice would not be of any help on the actual exam

Because the && operator has higher precedence than the || operator, I have to go for option 2 (like Sergei mentioned)

[Tony Singarayar]

Roel,
Please correct me where my understanding has gone wrong.

1.If the expression's operands doesn't have brackets, the expression is evaluated based on precedence of operator.
2.If the expression involves brackets(if one of the operand has brackets), evaluation is done from left to right only.
3. Which means that first operand is evaluated first and then its operated with remaining expression. Operator precedence doesn't come into play here...

If the above 3 points are true, Operation sequence of below code is....

(b1 = true) && (b2 = true) || (b3 = true);

1.true&&(b2 = true) || (b3 = true)
2.true&&true||(b3=true)
3.true||(b3=true)
4.returns true even thou (b3=true) is not evaluated.

Thanks,
Tony Singarayar

[Roel De Nijs]

Tony Singarayar wrote:1.If the expression's operands doesn't have brackets, the expression is evaluated based on precedence of operator.
2.If the expression involves brackets(if one of the operand has brackets), evaluation is done from left to right only.
3. Which means that first operand is evaluated first and then its operated with remaining expression. Operator precedence doesn't come into play here...

That's not 100% correct.

Let's use a few simple examples to explain the rules.

1. Operators with higher precedence are evaluated before operators with relatively lower precedence.

System.out.println(7 - 4 * 2); // -1

* has higher precedence than -, so 7 is evalauted first, then 4 * 2 is evaluated and finally 7 - 8 is evaluated.

2. When operators of equal precedence appear in the same expression, evaluation from left to right (except assignment operators which are evaluated right to left).

System.out.println(7 - 4 + 2); // 5

+ has same precedence than -, so 7 - 4 is evaluated first and then 3 + 2 is evaluated. (If evaluation was from right to left, the result would be 1; first 4 + 2, then 7 - 6)

3. Operator precedence can be overridden by using round brackets (parantheses)

System.out.println(7 - 4 * 2); // -1
System.out.println((7 - 4) * 2); // 6

Because of the parantheses, 7 - 4 is evaluated first and then 3 * 2 is evaluated.

So no parantheses in your example (b1 = true) && (b2 = true) || (b3 = true), so the expression is evaluated from left to right.

If you want to know in which order each part is executed you can add some helper methods. Using the following code you could also very easily change the return value and see its effect on which parts of the expression are evaluated.

public static void main(String[] args) {
    boolean b1, b2, b3;
    b1 = b2 = b3 = false;
    boolean result = (b1 = b(1, b1, b2, b3, true)) && (b2 = b(2, b1, b2, b3, true)) || (b3 = b(3, b1, b2, b3, true));
    System.out.printf("b1:%b  b2:%b  b3:%b result:%b%n", b1, b2, b3, result);
}
static boolean b(int i, boolean b1, boolean b2, boolean b3, boolean b) {
    System.out.printf("(b%d) b1:%b  b2:%b  b3:%b%n", i, b1, b2, b3);
    return b;
}

Hope it helps!
Kind regards,
Roel

[Tony Singarayar]

Thank You So much Roel!!!
Thanks for the detailed and stepwise answer.
That explains it all!!!
Tony Singarayar.

[Tony Singarayar]

Roel,
I pondered over your answer yesterday...I have few more queries.In the code below,

boolean b1, b2, b3;    
b1 = b2 = b3 = false;    
boolean result = (b1 = true) && (b2 = true) || (b3 = true);    
System.out.printf("b1:%b  b2:%b  b3:%b result:%b%n", b1, b2, b3, result); 

Since parentheses are takes priority over operator precedence, should parantheses-assignment((b1 = true),(b2 = true),(b3 = true)) be happening first.
The evaluation would simply become true && true|| true and result will be true aswell.
Please let me know whether to start a new topic.

Thanks,
Tony Singarayar

[Roel De Nijs]

Tony Singarayar wrote:Since parentheses are takes priority over operator precedence, should parantheses-assignment((b1 = true),(b2 = true),(b3 = true)) be happening first.

No, it doesn't work that way. Evaluation is still left to right. If parantheses would be always evaluated first, short-circuit operators would not exist (as shown in your example).

System.out.println(2 * (3 + 5));

In this example, first the 2 is evaluated (and not 3 + 5), then 3 + 5 is evaluated and finally 2 * 8.

This produces no output, but also no runtime exception:

int[] array = {1, 2, 3};
if (array.length > 3 && array[3] > 0)
  System.out.println("4th element positive");

I can add as many parantheses as I want, but these have no effect at all. This code snippet and the previous one are exactly the same:

int[] array = {1, 2, 3};
if ((((array.length > 3))) && ((array[3] > 0)))
  System.out.println("4th element positive");

And what happens if we replace the short-circuit && with &?

int[] array = {1, 2, 3};
if (array.length > 3 & array[3] > 0)
  System.out.println("4th element positive");

So evaluation is left to right, but you can override operator precedence using parantheses. But not all expressions in parantheses are evaluated first.

System.out.println(1 + 2 + 3 + 4 + 5 + 6);

Evaluation in this order: 1+2, 3+3, 6+4, 10+5 and 15+6

System.out.println((1 + 2) + (3 + 4) + (5 + 6));

This one is NOT evaluated in this order: 1+2, 3+4, 5+6, 3+7 and 10+11
but is evaluated in this order: 1+2, 3+4, 3+7, 5+6 and 10+11


Hope it helps!

[Prathima gaitonde]

I think I am getting it in bits and pieces but not fully, Sorry for not grasping it or missing the bits here,

What does associativity means?

What is its order out of 3

a>Order of evaluation
b>Order of precedence

and c>Associativity?

Thanks, for the help
Prathima

[Roel De Nijs]

Prathima gaitonde wrote:What does associativity means?

What is its order out of 3

a>Order of evaluation
b>Order of precedence
and c>Associativity?

Let us start with giving a definition of a few important terms mentioned in this thread:

Precedence order: When 2 operators share an operand the operator with the higher precedence goes first. Little example: 2 + 3 * 4 is treated as 2 + (3 * 4) (as multiplification has higher precedence than addition)

Associativity: When an expression has 2 operators with the same precedence, the expression is evaluated according to its associativity. Another little example: 12 - 6 - 6 can be treated as (12 - 6) - 6 or 12 - (6 - 6). And it's important to know as both results are different (0 or 12). The subtraction has left-to-right associativity, so 12 - 6 - 6 is treated as (12 - 6) - 6.

Order of evaluation of (sub)expressions: In Java (sub)expressions are evaluated from left to right.

Short circuiting: When using the conditional && and || operators, Java does not evaluate the 2nd operand unless it is necessary to resolve the result.

Let's take the 1st example from the original post again:

boolean b1,b2,b3; b1=b2=b3=false;
boolean result = (b1 = true) || (b2 = true) && (b3 = true);
System.out.printf("b1:%b  b2:%b  b3:%b result:%b", b1, b2, b3, result);

Order of evaluation is left-to-right, so we start with (b1 = true). This evaluates to true. Because the || operator is used, there is no need to evaluate the right side of the operator, because the left side is true, the result will always be true. So the right side of the || operator will never be evaluated. That's why the result is: b1:true b2:false b3:false result:true

Now let's see if you have understood and you can work out the following exercise itself. I made a small modification to the previous example. How is the 2nd line evaluated and what's the output?

boolean b1,b2,b3; b1=b2=b3=false;
boolean result = (b1 = true) && (b2 = true) || (b3 = true);
System.out.printf("b1:%b  b2:%b  b3:%b result:%b", b1, b2, b3, result);

Hope it helps!
Kind regards,
Roel

[Prathima gaitonde]

boolean b1,b2,b3; b1=b2=b3=false;  
boolean result = (b1 = true) && (b2 = true) || (b3 = true);  
System.out.printf("b1:%b  b2:%b  b3:%b result:%b", b1, b2, b3, result);  

My understanding,

1> Here in the above code associativity has no meaning as the operator && has higher precedence than operator ||.

2> Evaluation begins from left to right, Hence (((b1=true)&&(b2=true)) || (b3=true)), here b1=true first innermost bracket from left is evaluated then there is && operator, which is a short circuit, so as the b1=true it has to check for the value of b2 which is then assigned a value true. Now second innermost bracket from left results true, next operator is || as this short circuit operator looks for value true in the first place it wont evaluate value of b3, hence result is assigned a value true.

Hence final out put is b1=true, b2=true, b3=false, result=true.

Correct me if I am wrong.

@Roel De Nijs Thanks, for your patience and detailed explanation.....

[Roel De Nijs]

Prathima gaitonde wrote:Hence final out put is b1=true, b2=true, b3=false, result=true.

Correct me if I am wrong.

No need to correct you, your explanation (and final result) are spot-on

I only wonder why you added parantheses in the statement, because as you know: you can change the order of execution by adding parantheses. But luckily you added them on the right place So the original version (b1 = true) && (b2 = true) || (b3 = true) and your adapted version (((b1=true) && (b2=true)) || (b3=true)) are evaluated in exactly the same way

[Sharmili Rameshbabu]

Prathima gaitonde wrote:
2> Evaluation begins from left to right, Hence (((b1=true)&&(b2=true)) || (b3=true)), here b1=true first innermost bracket from left is evaluated then there is && operator, which is a short circuit, so as the b1=true it has to check for the value of b2 which is then assigned a value true. Now second innermost bracket from left results true, next operator is || as this short circuit operator looks for value true in the first place it wont evaluate value of b3, hence result is assigned a value true.

Hence final out put is b1=true, b2=true, b3=false, result=true.

I went through the entire discussion, still i dont understand one point that why should the evaluation actually happening is (((b1=true)&&(b2=true)) || (b3=true)), instead of (b1=true)&&((b2=true) || (b3=true))

In the second form also. && is given higher precedence and rest of the expression is considered as the second operand. Please advise

And which is given more priority, Precedence or Associativity? Because in the first example,(b1=true)||(b2=true) && (b3=true) , Associativity was considered. In the second one, (b1=true)&&(b2=true) || (b3=true) , Precedence is considered.

Many thanks

[Roel De Nijs]

Sharmili Rameshbabu wrote:I went through the entire discussion, still i dont understand one point that why should the evaluation actually happening is (((b1=true)&&(b2=true)) || (b3=true)), instead of (b1=true)&&((b2=true) || (b3=true))

In the second form also. && is given higher precedence and rest of the expression is considered as the second operand. Please advise

It's hard, very hard! So still being confused is not a big deal. Many seasoned java developers would struggle with these kind of questions. And I have to say: I didn't encounter such hard questions on the OCAJP7 exam.

According to the operator precedence page we know logical AND (&&) has a slightly higher precedence than logical OR (||). So that's why it makes sense to think, the expression is evaluated like ((b1=true) && (b2=true)) || (b3=true). But in this statement parentheses don't make any difference, the output is always the same. Illustrated with this code snippet:

public static void main(String[] args) {  
    method1(); method2(); method3();
}
static void method1() {
    boolean b1, b2, b3; b1 = b2 = b3 = false;
    boolean result = (b1=true) && (b2=true) || (b3=true);
    System.out.printf("b1:%b b2:%b b3:%b result:%b%n", b1, b2, b3, result);
}
static void method2() {
    boolean b1, b2, b3; b1 = b2 = b3 = false;
    boolean result = ((b1=true) && (b2=true)) || (b3=true);
    System.out.printf("b1:%b b2:%b b3:%b result:%b%n", b1, b2, b3, result);
}
static void method3() {
    boolean b1, b2, b3; b1 = b2 = b3 = false;
    boolean result = (b1=true) && ((b2=true) || (b3=true));
    System.out.printf("b1:%b b2:%b b3:%b result:%b%n", b1, b2, b3, result);
}

Every method will print the same line, so you'll get (if you run the program):
b1:true b2:true b3:false result:true
b1:true b2:true b3:false result:true
b1:true b2:true b3:false result:true

It gets more interesting when we switch the logical operators, as in the following code snippet:

public static void main(String[] args) {  
    method1(); method2(); method3();
}
static void method1() {
    boolean b1, b2, b3; b1 = b2 = b3 = false;
    boolean result = (b1=true) || (b2=true) && (b3=true);
    System.out.printf("b1:%b b2:%b b3:%b result:%b%n", b1, b2, b3, result);
}
static void method2() {
    boolean b1, b2, b3; b1 = b2 = b3 = false;
    boolean result = ((b1=true) || (b2=true)) && (b3=true);
    System.out.printf("b1:%b b2:%b b3:%b result:%b%n", b1, b2, b3, result);
}
static void method3() {
    boolean b1, b2, b3; b1 = b2 = b3 = false;
    boolean result = (b1=true) || ((b2=true) && (b3=true));
    System.out.printf("b1:%b b2:%b b3:%b result:%b%n", b1, b2, b3, result);
}

When you run this program, you'll get the following output:
b1:true b2:false b3:false result:true
b1:true b2:false b3:true result:true
b1:true b2:false b3:false result:true

As you can see, method1 and method3 have the same output, method2 has a different one. method1 doesn't have parantheses to override the order of execution like in method2 and method3. In method2 you'll have parantheses around the logical OR, in method3 the logical AND is put in between parantheses. So if you put parantheses around the logical OR (method2) you'll get a different output, so you have another evaluation of your expression (because of the use of parantheses).

And as a bonus I'll add this code example (very similar to the 1st code snippet):

public static void main(String[] args) {  
    method1(); method2(); method3();
}
static void method1() {
    boolean b1, b2, b3; b1 = b2 = b3 = false;
    boolean result = (b1=false) && (b2=true) || (b3=true);
    System.out.printf("b1:%b b2:%b b3:%b result:%b%n", b1, b2, b3, result);
}
static void method2() {
    boolean b1, b2, b3; b1 = b2 = b3 = false;
    boolean result = ((b1=false) && (b2=true)) || (b3=true);
    System.out.printf("b1:%b b2:%b b3:%b result:%b%n", b1, b2, b3, result);
}
static void method3() {
    boolean b1, b2, b3; b1 = b2 = b3 = false;
    boolean result = (b1=false) && ((b2=true) || (b3=true));
    System.out.printf("b1:%b b2:%b b3:%b result:%b%n", b1, b2, b3, result);
}

When you run this program, you'll get the following output:
b1:false b2:false b3:true result:true
b1:false b2:false b3:true result:true
b1:false b2:false b3:false result:false

Now the output of method1 and method2 is exactly the same and method3 is different. So that means method1 and method2 define the same evaluation of your expression. In method3 you have another evaluation (because of the use of parantheses). And to end this post: method1 and method2 are equivalent to (((b1=true)&&(b2=true)) || (b3=true)) and method3 is equivalent to (b1=true)&&((b2=true) || (b3=true)). As proven by the output, the 1st one is the correct evaluation.

Hope it helps!
Kind regards,
Roel

[Sharmili Rameshbabu]

Hi Roel,

Thanks for the reply with lot of experiments, i read your reply several times and I did a small research over few other possibilities like

 boolean b1, b2, b3,b4 = false; b1 = b2 = b3 = false;
		    boolean result = (b1=true) && (b2=false) || (b3=true) && (b4=true);

boolean b1, b2, b3,b4 = false; b1 = b2 = b3 = false;
		    boolean result = (b1=false) || (b2=false) && (b3=true) && (b4=true);

and able to predict the order of evaluation, having said that these type of questions are rare in the exam, am not going to spend more time on this.

And a small request, Can you please reply to my post here

With Regards
Sharmili

[Roel De Nijs]

Sharmili Rameshbabu wrote:And a small request, Can you please reply to my post here

No worries, it's still on my to do list to have a look and reply Please don't forget we are all volunteers here, so we have to do other things to get our bills paid in time.

[Sharmili Rameshbabu]

Sorry about that Roel! I completely understand and you guys are really doing an amazing job. I just assumed that my post was missed, that is the reason i reminded about it.

[Sachin Tripathi]

Hello Roel
This thread had created hell lot of confusions
Let me sum up things(considering op's first post)

1-&& has higher precedence than ||

2-so left to right executions begins

b2=true
&& doesn't get Short circuited
b3=true
true&&true=true

Now || has to be evaluated

(b1=true)||true

|| gets short circuited

Final result:

b1=false;b2=b3=result= true;


Where I am deviating from correct path,would love if you will point the exact step

[Henry Wong]

Sachin Tripathi wrote:
Where I am deviating from correct path,would love if you will point the exact step

Precedence does not determine the order of evaluation. The expression is evaluate left to right regardless of the precedence. In terms of operators only, for this expression ...

boolean result = (b1 = true) || (b2 = true) && (b3 = true);

1. The result assignment is evaluated first... but it can't be assigned until the complete RHS of the expression has completed.
2. The b1 assignment is evaluated next ... and b1 is set to true.
3. The logical OR operator is evaluated ... which short circuits the second operand.

Now... as for what is the second operand, the precedence helps determine that. Since the logical AND operator is higher in precedence than the logical OR, both the b2 and b3 portions of the expression are part of the second operand (and hence, short circuited).

Henry

[Roel De Nijs]

Sachin Tripathi wrote:Where I am deviating from correct path,would love if you will point the exact step

You go on the wrong path, because you don't evaluate b1 first and start immediately with the right hand side (RHS). And if you think about it, it makes no sense at all: the || operator is a short-circuit operator. Meaning if the left hand side (LHS) evaluates to true, the RHS is not evaluated at all. And you start evaluating with the RHS (which might not be evaluated at all). Like Henry already stated: expressions are evaluated from left to right, regardsless of the precedence. So b1 is evaluated first and because it's evaluated to true, the RHS of the || operator is not evaluated anymore.

Let's put that statement in my "magic" program and see if we got it spot-on. So the statement

boolean result = (b1 = true) || (b2 = true) && (b3 = true);

becomes (only line4 actually matters)

public static void main(String[] args) {
    boolean b1, b2, b3;
    b1 = b2 = b3 = false;
    boolean result = (b1 = b(1, b1, b2, b3, true)) || (b2 = b(2, b1, b2, b3, true)) && (b3 = b(3, b1, b2, b3, true));
    System.out.printf("b1:%b  b2:%b  b3:%b result:%b%n", b1, b2, b3, result);
}
static boolean b(int i, boolean b1, boolean b2, boolean b3, boolean b) {
    System.out.printf("(b%d) b1:%b  b2:%b  b3:%b%n", i, b1, b2, b3);
    return b;
}

Output:
(b1) b1:false b2:false b3:false
b1:true b2:false b3:false result:true
So yes, we were absolutely 100% correct

Now let's see if adding parantheses would result in a different output.

1/ ((b1 = true) || (b2 = true)) && (b3 = true) (parantheses around ||)

boolean result = ((b1 = b(1, b1, b2, b3, true)) || (b2 = b(2, b1, b2, b3, true))) 
    && (b3 = b(3, b1, b2, b3, true));

Output:
(b1) b1:false b2:false b3:false
(b3) b1:true b2:false b3:false
b1:true b2:false b3:true result:true

2/ (b1 = true) || ((b2 = true) && (b3 = true)) (parantheses around &&)

boolean result = (b1 = b(1, b1, b2, b3, true)) || ((b2 = b(2, b1, b2, b3, true)) 
    && (b3 = b(3, b1, b2, b3, true)));

Output:
(b1) b1:false b2:false b3:false
b1:true b2:false b3:false result:true

Conclusion: adding parantheses matters! And (b1 = true) || (b2 = true) && (b3 = true) is equivalent to (b1 = true) || ((b2 = true) && (b3 = true)).

In this thread you'll find a few other examples about the same topic and some examples are using the | operator (which is not a short-circuit operator and thus always evaluates both sides).

Hope it helps!
Kind regards,
Roel

[Sachin Tripathi]

Thanks a lot
Roel and Henry

The reason behind the answer which i gave:

int c=7-4*3;
System.out.println(c);

Output:

5

Evaluation = precedence(R to L)

[Roel De Nijs]

Sachin Tripathi wrote:Output:

5

Huh

The output of this code snippet

int c=7-4*3;
System.out.println(c);

is -5 (not 5)

[Sachin Tripathi]

Sorry -5

@

[Henry Wong]

Sachin Tripathi wrote:
The reason behind the answer which i gave:

int c=7-4*3;
System.out.println(c);

Output:

5

Evaluation = precedence(R to L)

With this latest example, there aren't any operations with side effects, so evaluation order probably doesn't matter ... but ... the order of evaluation is still left to right, regardless of precedence.

So, let's look at the order of evaluation (even without any side effect concerns), just like with the example in my last post. In terms of operators only (evaluating left to right) ...

1. The c assignment is evaluated first... but it can't be assigned until the complete RHS of the expression has completed (due to precedence)
2. The subtraction operator is evaluated next ... the left operand is 7, but the right operand needs to be completed (due to precedence)
3. The multiplication operator is evaluated next ... the left operand is 4, the right operand is 3, so the result is 12

2a. The right operand completes evaluation with 12 -- and hence, the result is -5.
1a, The RHS of the expression completes evaluation with -5 -- and hence, the assignment can be completed

Again. One more time. Because I love beating a dead horse... ... Precedence and Order of Evaluation are two different things. And Order of Evaluation is left to right.

Henry

[Sachin Tripathi]

I think ,now i started getting things

Evaluation always occurs from L to R

But during evaluation if operator has less precedence then following operator then the final result of operation involving less precedence operator is given after operation involving higher precedence one is given(this is general case)


But if operator has a property of short circuit and left operand compels short circuit then final result of operation involving less precedence operator can be given depending upon their position in their expression

Correct me if I m wrong

[Roel De Nijs]

Sachin Tripathi wrote:Evaluation always occurs from L to R

But during evaluation if operator has less precedence then following operator then the final result of operation involving less precedence operator is given after operation involving higher precedence one is given(this is general case)

Illustrated with a few examples in this post and this one.

Sachin Tripathi wrote:But if operator has a property of short circuit and left operand compels short circuit then final result of operation involving less precedence operator can be given depending upon their position in their expression

Having difficulties with understanding that statement, so it's hard to tell if you are correct or wrong.

[Sachin Tripathi]

To make my point clear,consider op's first question
In which || has less precedence then &&
Even though due to short circuit property the result due to || is evaluated first without evaluating &&
Because it is the leftmost operator

[Roel De Nijs]

Sachin Tripathi wrote:To make my point clear,consider op's first question
In which || has less precedence then &&
Even though due to short circuit property the result due to || is evaluated first without evaluating &&
Because it is the leftmost operator

And what about

boolean result = (b1 = false) || (b2 = true) && (b3 = true);

and

boolean result = ((b1 = false) || (b2 = true)) && (b3 = true);

[Sachin Tripathi]

1-In this || has less precedence then &&
b1=false
short circuit doesn't happen,for RHS of || ,&& has to be evaluated first(higher precedence)
b2=true
short circuit doesn't happen,
b3=true


true &&true=true
false||true=true

So b1=false b2=b3=result=true


2-In which || has less precedence then &&
b1=false
short circuit doesn't happen,for RHS of ||
b2=true(as due to presence of parenthesis, && is not evaluated)
false||true=true
b3=true
true &&true=true

So b1=false,b2=b3=result=true

[Roel De Nijs]

Sachin Tripathi wrote:1- So b1=false b2=b3=result=true
2- So b1=false,b2=b3=result=true

Spot on! I think you have a good understanding now of this concept.