Java – Precedence of ++ and — Operators in Java

incrementjavaoperator-precedencepostfix-operatorprefix

I read from the official tutorial of Java that prefix and postfix ++ — have different precedences:

postfix: expr++ expr–

unary: ++expr –expr +expr -expr ~ !

According to the tutorial, shouldn't this

d = 1; System.out.println(d++ + ++d);

print out 6 (d++ makes d 2, ++d makes it 3) instead of 4?

I know the explanation of ++d being evaluated beforehand, but if d++ has higher precedence then ++d, why isn't d++ being first evaluated? And what is more, in what case should d++ shows that it has higher precedence?

EDIT:

I tried the following:

d = 1; System.out.println(++d * d++);

It returns 4. It seems that it should be 2*2, instead of 1*3.

Best Answer

The inside of the println statement is this operation (d++) + (++d)

It is as follows, the value of d is read (d = 1)
current value of d (1) is put into the addition function
value of d is incremented (d = 2).
Then, on the right side, the value of d is read (2)
The value of d is incremented (now d = 3)
Finally, the value of d (3) is put into the addition function

thus 1 + 3 results in the 4

edit: sorry for the format, I'm rather bad at using the list haha

Related Solutions

Java – Prefix and Postfix Increment/Decrement Operators

i = 5;
System.out.println(++i); //6

This prints out "6" because it takes i, adds one to it, and returns the value: 5+1=6. This is prefixing, adding to the number before using it in the operation.

i = 6;
System.out.println(i++); //6 (i = 7, prints 6)

This prints out "6" because it takes i, stores a copy, adds 1 to the variable, and then returns the copy. So you get the value that i was, but also increment it at the same time. Therefore you print out the old value but it gets incremented. The beauty of a postfix increment.

Then when you print out i, it shows the real value of i because it had been incremented: 7.

Java Operator Precedence – Understanding Pre- and Postfix Operators

The confusion stems from the fact that the operands are evaluated from left to right. This is done first, before any attention is paid to operator precedence/order of operations.

This behavior is specified in JLS 15.7.2. Evaluate Operands before Operation

So X++ * ++X * X++ is first evaluated as 10 * 12 * 12 which yields, as you saw, 1440.

To convince yourself of this, consider the following:

X = 10; System.out.println(X++ * ++X);
X = 10; System.out.println(++X * X++);

If X++ were done first, then ++X second, then multiplication, both should print the same number.

But they do not:

X = 10; System.out.println(X++ * ++X); // 120
X = 10; System.out.println(++X * X++); // 121

So how does this make sense? Well if we realize that operands are evaluated from left to right, then it makes perfect sense.

X = 10; System.out.println(X++ * ++X); // 120 (10 * 12)
X = 10; System.out.println(++X * X++); // 121 (11 * 11)

The first line looks like

X++       * ++X
10 (X=11) * (X=12) 12
10        * 12 = 120

and the second

++X       * X++
(X=11) 11 * 11 (X=12)
11        * 11 = 121

So why are prefix and postfix increment/decrement operators in the table?

It is true that increment and decrement must be performed before multiplication. But what that is saying is that:

Y = A * B++

// Should be interpreted as
Y = A * (B++)

// and not
Y = (A * B)++

Just as

Y = A + B * C

// Should be interpreted as
Y = A + (B * C)

// and not
Y = (A + B) * C

It remains that the order of the evaluation of the operands occurs left-to-right.

If you're still not conviced:

Consider the following program:

class Test
{
    public static int a(){ System.out.println("a"); return 2; }
    public static int b(){ System.out.println("b"); return 3; }
    public static int c(){ System.out.println("c"); return 4; }

    public static void main(String[] args)
    {
        System.out.println(a() + b() * c());
        // Lets make it even more explicit
        System.out.println(a() + (b() * c()));
    }
}

If the arguments were evaluated at the time they were needed, either b or c would come first, the other next, and lastly a. However, the program outputs:

a
b
c
14
a
b
c
14

Because, regardless of the order that they're needed and used in the equation, they're still evaluated left to right.

Helpful reading: