operation on post++ and --pre operator

Question

I am wondering with post and pre increment and decrement operation.

what I know in Java precedence of post operator is high and associativity is left-to-right.while associativity of pre operator is right-to-left

Oracle Java Tutorial

but my code showing me undesired result-

public class Bunnies { 
    static int count = 3; 
    public static void main(String[] args) { 

        System.out.println(--count*count++*count++);//out put is 12 expected 48
        //associativity of post is higher so should be evaluated like this-

        //--count*3**count++  count is 4 now
        //--count*3*4         count is 5 now
        //4*3*4=48


        count = 3;
        System.out.println(--count*++count*++count); //out put is 24 expected 120
        //associativity of pre  is right to left so should be evaluated like this-

        //--count*++count*4      count is 4 now
        //--count*5*4            count is 5 now
        //4*5*4=120


        count = 3;
        System.out.println(-- count*count++);// out put is 4 expected 9

        //--count*3      count is 4 now
        //3*3=9 
         }
}

Answer 1

Order of evaluation of subexpressions is independent of both associativity and precedence.

The subexpression of the multiplication are evaluated from left to right, so when doing --count*count++*count++, you evaluate --count then count++ and finally count++.

And as the pre operator is evaluated first, --count will be decremented before its evaluation. In the same way, as the post operator is evaluated lately, count++ will be incremented after its evaluation.

The precedence only help the compiler to create a correct abstract syntactic tree.
For example, when doing ++count*2, the compiler use the precedence to know the expression is (++count)*2 and not ++(count*2). In the same way, when doing ++count*count--, the expression is (++count)*(count--) and not (++(count * count))-- or whatever. But then, during the evaluation of the multiplication ++count is evaluated before count--.

Hope this help you :)

I just found a great answer about expression evaluation in C# and Java here, enjoy :)

Answer 2

System.out.println(--count*count++*count++);

= 2 * 2 * 3 = 12

count = 3;
System.out.println(--count*++count*++count) 

= 2*3*4 = 24

count = 3;
System.out.println(-- count*count++);

= 2 * 2 = 4

Pre increment/decrement

++/-- X first increments/decrements then does the operation.

Post increment/decrement

X ++/-- first the operation is done, then increment / decrement.

Answer 3

I take the first one.

System.out.println(--count*count++*count++);//out put is 12 expected 48
                    2     *    2  * 3 = 12
                    pre   * post  * post

Answer 4

count = 3:

Example 1:

--count*count++*count++ equals (--count)*(count++)*(count++)
(--count) = 2
(count++) = 2 (you increment it AFTER you do something with it)
(count++) = 3 ... count was incremented from before
2*2*3 = 12

Example 2:

--count*++count*++count equals (--count)*(++count)*(++count)
--count = 2
++count = 3
2 * 3 * 3 = 24

Example 3:

(--count)*(count++)
--count = 2
2 * 2 (the count++ gets changed afterwards)

Keep in mind that you have to watch the multiplicaton operator