Trouble understanding order of execution in a java algorithm (k= and ++k)

Question

I've had to do a Java exam recently, and was wondering about one of the questions I had wrong. The question was as follows:

What will the following code print when run without any arguments ...

public class TestClass {

    public static int m1(int i){
        return ++i;
    }

    public static void main(String[] args) {
        int k = m1(args.length);
        k += 3 + ++k;
        System.out.println(k);
    }

}

With the answers being a number between 1 and 10. My original answer was 7, whereas they state that the correct one is 6.

My logic:

m1 sets k to 1, as it's ++i and thus gets incremented prior to returning.
then the += is unrolled, making: 'k = k + 3 + ++k'.
++k is executed, making k 2.
Replace the variables with their value: 'k = 2 + 3 + 2'
k = 7.

However, they state it as k = 1 + 3 + 2. Could anyone explain as to why the variable is replaced first, before performing the ++k?

Answer 1

The post and pre increment operators do operate on a temporary value which is getting assigned after the equation. Which means that

i = 0;
i = i++ // still 0
i = ++i // 1

Because the right hand side is temporary and do not reflect the left side before the assignment.

With your logic this would result in

int i = 0;
i = ++i // 2 - wrong.

Answer 2

Without any arguments means args.length = 0

int k = m1(args.length); m1 (0) = ++0 = 1

So k = 1

k += 3 + ++k;

k = k + 3 =4. ++k = ++1 = 2

So

4 + 2 = 6

Answer 3

I do believe that even if the order is correct, the JVM prepare the statement with the k value so this is looking like this (simplified) :

  k += 3+ ++k; // k = 1
> k = k + 3 + ++k // k = 1
> k = 1 + 3 + ++k // k = 1 
> k = 1 + 3 + 2   // k = 2

Let go further with :

  int k = 2;
  k *= 3 + ++k; // > 12
> k = 2 * 3 + ++k // k = 2
> k = 2 * 3 + ++k // k = 2
> k = 2 * 3 + 3   // k = 3
> k = 2 * 6 = 12

We see that the *= is done last be with the beginning value.

  int k = 1;
  k += 3 + ++k + ++k; // > 9
> k = k + 3 + ++k + ++k // k = 1
> k = 1 + 3 + ++k + ++k // k = 1
> k = 1 + 3 + 2   + ++k // k = 2
> k = 1 + 3 + 2   + 3   // k = 3
> k = 9

So we can see that this is not true for post increment. Those will get the value of k on the first reading

The only logic I see is that the values are evaluated from left to right but the operator are only executed depending on the order. At the exception of post and pre increment that are evaluated during the first reading

Answer 4

Ok, you are correct in stating that the ++ operator has precedence over the += operator and therefore the += will not be unrolled until the ++ operation has been carried out .... however before any operation is carried out the interpreter first evaluates the operands of most operators and this is done from left to right.

So in your example, where k = 1,

k += 3 + ++k;

effectively is:

1 += 3 + ++k;

and then the ++k is evaluated as this has precedence and becomes:

1 += 3 + 2;

the + has precedence and becomes:

1 += 5;

and at this point the += is unrolled, which of course gives 6 ... QED

Edit

Although operator precedence is important Java does evaluate left to right unless the precedence dictates otherwise:

For example:

a + b + c * d

Although c * d has precedence it isn't evaluated first.

a + b + c * d
  ^   ^
 these 2 operators compared

Both have same level of precedence so evaluating left to right and a + b is evaluated first (lets call the result d).

 d + c * d
   ^   ^
 next these 2 operators compared

* has precedence over + so c * d is evaluated first.