Maybe I’m just being pedantic, but I think I’ve just found a mistake in the Java Tutorial. It claims:

All binary operators except for the assignment operators are evaluated from left to right; assignment operators are evaluated right to left.

The Java™ Tutorials » Language Basics » Operators

What is this supposed to mean? Evaluation from right to left would mean that when you have a line like the following you get the rightmost expression evaluated first:

```
int x = 42;
x += getNumber();
// The above would be equivalent to:
x = getNumber() + x;
```

But that’s not how Java actually evaluates this expression. And the JLS 12 (2019-02-08) clearly states in 15.26.2 that “the value of the left-hand operand is saved and then the right-hand operand is evaluated.”

This explains it best:

A compound assignment expression of the form

JLS 12, 15.26.2 Compound Assignment Operators`E1 op= E2`

is equivalent to`E1 = (T) ((E1) op (E2))`

, where`T`

is the type of`E1`

, except that`E1`

is evaluated only once.

So the above code is actually equal to this:

```
x = (int) (x + getNumber());
```

Addition is commutative, so it doesn’t matter. But we also have `/=`

, which is not commutative. You can test this by using a static field for `x`

and some side effect (such as `System.out.println`

and some assignment to `x`

) in `getNumber()`

.

```
public class SomeClass {
static int x = 42;
public static void main(String[] args) {
// assignment operators are evaluated right to left?
x += getNumber();
// equal to:
// x = x + getNumber();
System.out.println(x);
}
static int getNumber() {
System.out.println("getNumber");
x = Integer.MIN_VALUE;
return 58;
}
}
```

This code will print 100. That’s because the old value of `x`

(42) is used. If x was evaluated after `getNumber()`

you would get -2147483590 instead.

Contrary to that the Tutorial says all assignments are evaluated **left to right**. But all the assignment operators are **right-associative**. That might be the reason for the mix-up.

There are 12 assignment operators; all are syntactically right-associative (they group right-to-left). Thus,

JLS 12, 15.26 Assignment Operators`a=b=c`

means`a=(b=c)`

, which assigns the value of`c`

to`b`

and then assigns the value of`b`

to`a`

.

Example:

```
public static void main(String[] args) {
int x = 42, y = 58;
x += y *= x;
// equal to:
// x = x + (y = y*x);
System.out.println(x);
}
```

It would not make any sense if they were left-associative.

The Tutorial should be corrected to say:

All binary operators except for the assignment operators are

groupedfrom left to right; assignment operators aregroupedright to left.

Or:

All binary operators except for the assignment operators are

left-associative; assignment operators areright-associative.