Valeur de i pour (i == -i && i! = 0) pour renvoyer true en Java

J'ai la ifcondition suivante .

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

Quelle valeur de iretournera truepour cette condition en Java?

Je suis incapable de penser à une telle valeur de iconsidérer la notation du complément à deux en Java.

J'aimerais aussi avoir une preuve algébrique de la réponse de cette condition (dans le contexte de Java)?

La seule intvaleur pour laquelle cela fonctionne est Integer.MIN_VALUE.

C'est parce que les entiers sont annulés en utilisant la méthode du complément à deux .

En utilisant

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

vous voyez que Integer.MIN_VALUEc'est

10000000000000000000000000000000

Prendre la valeur négative se fait en échangeant d'abord 0et 1, ce qui donne

01111111111111111111111111111111

et en ajoutant 1, ce qui donne

10000000000000000000000000000000

Comme vous pouvez le voir dans le lien que j'ai donné, Wikipédia mentionne le problème avec les nombres les plus négatifs et précise que c'est la seule exception:

Le nombre le plus négatif dans le complément à deux est parfois appelé "le nombre étrange", car c'est la seule exception.

Bien sûr, vous avez le même phénomène Long.Min_Valuesi vous le stockez dans une longvariable.

Notez que cela est uniquement dû aux choix qui ont été faits concernant le stockage binaire des ints en Java . Une autre (mauvaise) solution aurait pu par exemple être de nier en changeant simplement le bit le plus significatif et en laissant les autres bits inchangés, cela aurait évité ce problème avec MIN_VALUE mais aurait fait 2 0valeurs différentes et une arithmétique binaire compliquée (comment auriez-vous incrémenté par exemple?).

La valeur que vous recherchez est Integer.MIN_VALUE.

J'aimerais aussi avoir une preuve algébrique de la réponse de cette condition (dans le contexte de java)?

C'est hors sujet pour Stack Exchange. Mais vous pouvez le faire à partir de la définition des entiers Java ( JLS 4.2 )

"Les types intégraux sont byte, short, int et long, dont les valeurs sont des entiers à complément à deux signés 8 bits, 16 bits, 32 bits et 64 bits ..."

et

"Les valeurs des types intégraux sont des entiers dans les plages suivantes ... Pour int, de -2147483648 à 2147483647, inclus"

et la définition de l'opérateur unaire Java '-' ( JLS 15.15.4 ):

"Pour les valeurs entières, la négation est la même que la soustraction à partir de zéro. Le langage de programmation Java utilise une représentation du complément à deux pour les entiers, et la plage des valeurs du complément à deux n'est pas symétrique, donc la négation du maximum négatif int ou long entraîne que même nombre négatif maximum. Un dépassement de capacité se produit dans ce cas, mais aucune exception n'est émise. Pour toutes les valeurs entières x, -x est égal à (~ x) +1. "

En plus des réponses données jusqu'à présent ...

Il y a quatre valeurs au total

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

Les valeurs encapsulées sont déballées et sont donc également vraies pour cette expression.

Remarque: documents Math.abs.

public static int abs (int a)

Renvoie la valeur absolue d'une valeur int. Si l'argument n'est pas négatif, l'argument est renvoyé. Si l'argument est négatif, la négation de l'argument est renvoyée.

Notez que si l'argument est égal à la valeur de Integer.MIN_VALUE, la valeur int représentable la plus négative, le résultat est la même valeur, qui est négative.

et

public statique long abs (long a)

Renvoie la valeur absolue d'une valeur longue. Si l'argument n'est pas négatif, l'argument est renvoyé. Si l'argument est négatif, la négation de l'argument est renvoyée.

Notez que si l'argument est égal à la valeur de Long.MIN_VALUE, la valeur longue représentable la plus négative, le résultat est la même valeur, qui est négative.

Il est surprenant que Math.abs renvoie un nombre négatif. Cela se produit soit parce que a) il n'y a pas de valeurs positives pour -MIN_VALUE dans ces cas b) l'exécution du -calcul entraîne un débordement.

Ce qui est également intéressant, c'est pourquoi Byte.MIN_VALUE, Short.MIN_VALUE ne le font pas. Ceci est dû au -fait que le type change intpour ceux-ci et donc aucun débordement.

Character.MIN_VALUE n'a pas de problème car il est égal à 0.

Float.MIN_VALUE et Double.MIN_VALUE ont une signification différente. Il s'agit de la plus petite valeur représentable supérieure à zéro. Ainsi, ils ont des valeurs négatives valides qui ne sont pas elles-mêmes.

Comme les autres l'ont mentionné, cela n'est accompli que par Integer.MIN_VALUE. Quant à la preuve, permettez-moi d'offrir une explication plus facile à comprendre autrement qu'en binaire (bien qu'elle soit toujours enracinée dans cela).

Notez que Integer.MIN_VALUEest égal à -2^31ou -2147483648et Integer.MAX_VALUEest égal à 2^31-1ou 2147483647. -Integer.MIN_VALUEis 2^31, qui est maintenant trop grand pour un entier (puisqu'il est passé MAX_VALUE) provoquant ainsi un débordement d'entier, le faisant à Integer.MIN_VALUEnouveau. C'est le seul entier qui fait cela puisque MIN_VALUEc'est le seul nombre sans équivalent négatif à part 0.

Preuve algébrique provisoire, utilisant l' modulo 2^32arithmétique:

i == -ipeut être réécrit comme 2 * i == 0(en ajoutant des ideux côtés), ou i << 1 == 0.

Cette équation a deux solutions de la forme i == 0 >> 1, à savoir 0bet 10000000000000000000000000000000bobtenue en se déplaçant vers la gauche 0ou 1vers la gauche.

La solution i == 0étant exclue, il reste la solution i == 100000000000000000000000000000000b.

Ce n'est peut-être pas trop instructif, mais au lieu de penser que vous pourriez exécuter ce code:

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

pour voir qu'il imprime

-2147483648
-2147483648

infiniment :)