Почему оценка операторов Java происходит так?

Сначала вы должны очистить информацию о преинкременте и постинкременте. Давайте посмотрим

int i=1;
int j=i++;
int k=++i;

здесь в значении j будет 1, а k будет 3

почему означает, что в i++ сначала сохраняется значение i в j, а затем увеличивается значение i, поэтому

j=1,i=2 ok :)

теперь в случае ++i, где сначала увеличивается значение, а затем сохраняется в k, поэтому

k=3,i=3 ok :)

теперь я перехожу к вашему вопросу

int z = 1; System.out.println(z++ == ++z);

так подскажите что будет z++ ? 1 ок :) значит ++z будет ? 3поэтому оператор напечатает false ok :) и второй случай

System.out.println(++z == z++);

++z будет 4, а z++ будет 4, так что вы получили true Так что надеюсь, вы справитесь...

Операнды == оцениваются слева направо справа, а ++ имеет более высокий приоритет, поэтому ваш код эквивалентен:

int z = 1;
int tmp1 = z++; //tmp1 = 1 / z = 2
int tmp2 = ++z; //tmp2 = 3 / z = 3
System.out.println(tmp1 == tmp2);

tmp1 = ++z; //tmp1 = 4 / z = 4
tmp2 = z++; //tmp2 = 4 / z = 5
System.out.println(tmp1 == tmp2);

Я предполагаю, что вы понимаете разницу между z++ и ++z:

• tmp1 = z++; можно разбить на: tmp1 = z; z = z + 1;
• тогда как tmp2 = ++z; можно разбить на: z = z + 1; tmp2 = z;

int z = 1;
    System.out.println(z++ == ++z);
    System.out.println(++z == z++);

z++ — постинкремент, ++z — преинкремент. Приращение поста увеличивает значение после вычисления выражения, а приращение предварительного приращения увеличивает значение до того, как выражение будет оценено.

Следовательно,

int z = 1;
    System.out.println(z++ == ++z); // 1 == 3 false
    System.out.println(++z == z++);// 4 == 4 true

оператор == отдает приоритет тому, что находится слева от него, другими словами, поскольку он работает с двумя значениями, значения слева оцениваются первыми.

оператор ++ перед меткой переменной указывает, что приращение присваивается значению перед его вычислением, тот же оператор, поставленный после метки, вызывает постинкремент, означающий, что значение переменной увеличивается на 1 после ее вычисления.

относительно второй строки вашего кода:

• оператор == смотрит налево
• оператор оценивает z как 1
• оператор сделал с левой частью, но приращение сделано из-за вашего z++, что просто говорит о том, что приращение после z оценивается, поэтому теперь z равно 2, но оценивается оператором == как 1, помните это.
• оператор == смотрит справа
• оператор не может оценить, что находится в z, не делая приращения из-за ++z, это означает, что z оценивается как 3

1 != 3.

те же понятия применяются к следующей строке.

System.out.println(z++ == ++z); // 1 == 3 is false
System.out.println(++z == z++); // 4 == 4 is true

При использовании значения постинкремента копируется во временную переменную 'tmp', проверьте здесь постинкремент. Таким образом, z++ == ++z => оценивается как 1 == 3, что является ложным. Теперь z равно 3.

Переходя ко второму выражению: ++z == z++, снова: ++z становится 4, а в случае z++ значение копируется в переменную tmp и используется в z++. Выражение становится 4 == 4, что является истинным, и окончательное значение z is 5

Оператор ++z возвращает увеличенное значение z, тогда как z++ возвращает свое предыдущее значение до увеличения, однако значение z после возврата выражения z++ является увеличенным значением z.

so

int z = 1;                                        // Line 1
System.out.println(z++ == ++z);                   // Line 2
System.out.println(++z == z++);                   // Line 3

В строке 2 z++ возвращает 1, а значение z увеличивается после возврата, поэтому z теперь равно 2, а ++z увеличивает значение перед возвратом, поэтому z равно 3. Следовательно, строка 2

System.out.println(1 == 3);

что является ложным.

В строке 3 ++z оценивается как 4 (поскольку предыдущее значение z равно 3), а z++ снова возвращает предыдущее значение z, то есть 4, но теперь z равно 5. Поэтому строка 3

System.out.println(4 == 4);

что правда.