Значение i для (i == -i && i! = 0) для возврата true в Java

У меня следующее ifсостояние.

if (i == -i && i != 0)

Какое значение iвернет trueдля этого условия в Java?

Я не могу придумать какой-либо такой ценности для iрассмотрения двух дополнений в Java.

Я также хотел бы получить алгебраическое доказательство того, какой ответ это условие имеет (в контексте Java)?

Единственное intзначение, для которого это работает Integer.MIN_VALUE.

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

С помощью

System.out.println(Integer.toBinaryString(Integer.MIN_VALUE));

вы видите, что Integer.MIN_VALUEэто

10000000000000000000000000000000

Принятие отрицательного значения выполняется сначала заменой местами 0и 1, что дает

01111111111111111111111111111111

и добавив 1, что дает

10000000000000000000000000000000

Как вы можете видеть в приведенной мной ссылке, Википедия упоминает проблему с наиболее отрицательными числами и указывает ее единственное исключение:

Самое отрицательное число в дополнении до двух иногда называют «странным числом», потому что это единственное исключение.

Конечно, у вас будет то же самое явление, Long.Min_Valueесли вы сохраните его в longпеременной.

Обратите внимание, что это связано только с выбором, который был сделан в отношении двоичного хранения int в Java . Другое (плохое) решение могло, например, заключаться в том, чтобы отменить, просто изменив наиболее значимый бит и оставив другие биты неизменными, это позволило бы избежать этой проблемы с MIN_VALUE, но сделало бы 2 разных 0значения и сложную двоичную арифметику (как бы вы увеличено например?).

Ценность, которую вы ищете Integer.MIN_VALUE.

Я также хотел бы получить алгебраическое доказательство того, какой ответ это условие имеет (в контексте с java)?

Это не по теме для Stack Exchange. Но вы могли бы сделать это, начиная с определения целых чисел Java ( JLS 4.2 )

«Целочисленные типы - это byte, short, int и long, значения которых - 8-битные, 16-битные, 32-битные и 64-битные целые числа с дополнением до двух со знаком ...»

и

"Значения целочисленных типов являются целыми числами в следующих диапазонах ... Для int от -2147483648 до 2147483647 включительно"

и определение унарного оператора Java '-' ( JLS 15.15.4 ):

"Для целочисленных значений отрицание аналогично вычитанию из нуля. В языке программирования Java для целых чисел используется представление с дополнением до двух, а диапазон значений с дополнением до двух несимметричен, поэтому отрицание максимального отрицательного int или long приводит к тому, что такое же максимальное отрицательное число. В этом случае происходит переполнение, но исключение не возникает. Для всех целых значений x, -x равно (~ x) +1. "

В дополнение к ответам, данным до сих пор ...

Всего существует четыре значения

int i = Integer.MIN_VALUE;
long i = Long.MIN_VALUE;
Integer i = Integer.valueOf(Integer.MIN_VALUE);
Long i = Long.valueOf(Long.MIN_VALUE);

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

Примечание: документы Math.abs.

общедоступный статический int abs (int a)

Возвращает абсолютное значение типа int. Если аргумент не отрицательный, возвращается аргумент. Если аргумент отрицательный, возвращается отрицание аргумента.

Обратите внимание, что если аргумент равен значению Integer.MIN_VALUE, наиболее отрицательному представимому значению int, результатом будет то же самое значение, которое является отрицательным.

и

публичный статический длинный пресс (длинный а)

Возвращает абсолютное значение длинного значения. Если аргумент не отрицательный, возвращается аргумент. Если аргумент отрицательный, возвращается отрицание аргумента.

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

Удивительно, что Math.abs может возвращать отрицательное число. Это происходит либо потому, что: а) в этих случаях нет положительных значений для -MIN_VALUE; б) выполнение -вычислений приводит к переполнению.

Интересно также, почему этого не делают Byte.MIN_VALUE, Short.MIN_VALUE. Это связано с тем, что для них -изменяется тип, intи, следовательно, нет переполнения.

Character.MIN_VALUE не имеет проблем, потому что он равен 0.

Float.MIN_VALUE и Double.MIN_VALUE имеют разное значение. Это наименьшее представимое значение больше нуля. Таким образом, они имеют действительные отрицательные значения, которые не являются самими собой.

Как уже упоминалось другими, это выполняется только Integer.MIN_VALUE. Что касается доказательства, позвольте мне предложить более легкое для понимания объяснение, отличное от двоичного (хотя оно все еще основано на этом).

Обратите внимание, что Integer.MIN_VALUEэто равно -2^31или -2147483648и Integer.MAX_VALUEравно 2^31-1или 2147483647. -Integer.MIN_VALUEis 2^31, которое теперь слишком велико для целого числа (поскольку оно прошло MAX_VALUE), что вызывает переполнение целого числа, что делает его Integer.MIN_VALUEснова. Это единственное целое число, которое делает это, поскольку MIN_VALUEэто единственное число без отрицательного эквивалента, кроме 0.

Предварительное алгебраическое доказательство с использованием modulo 2^32арифметики:

i == -iможно переписать как 2 * i == 0(добавляя iс обеих сторон), или i << 1 == 0.

Это уравнение имеет два решения вида i == 0 >> 1: 0bи, 10000000000000000000000000000000bполучаемые сдвигом влево 0или 1вправо.

Решение i == 0исключено, остается решение i == 100000000000000000000000000000000b.

Возможно, это не слишком поучительно, но вместо того, чтобы думать, что вы можете запустить этот код:

    for (int i = Integer.MIN_VALUE; i <= Integer.MAX_VALUE; i++)
    {
        if (i == -i && i != 0)
        {
            System.out.println(i);
        }
    }

чтобы увидеть, что он печатает

-2147483648
-2147483648

бесконечно :)