Comment les entiers sont-ils représentés en interne à un niveau de bits en Java?

Les entiers Java sont de 32 bits, et toujours signés. Cela signifie que le bit le plus significatif (MSB) fonctionne comme le bit de signe. L'entier représenté par un int n'est rien d'autre que la somme pondérée des bits. Les poids sont attribués comme suit:

Bit#    Weight
31      -2^31
30       2^30
29       2^29
...      ...
2        2^2
1        2^1
0        2^0

Notez que le poids du MSB est négatif (le plus grand négatif possible en fait), donc quand ce bit est activé, le nombre entier (la somme pondérée) devient négatif.

Simulons-le avec 4 bits nombre:

Binary    Weighted sum            Integer value
0000       0 + 0 + 0 + 0           0
0001       0 + 0 + 0 + 2^0         1
0010       0 + 0 + 2^1 + 0         2
0011       0 + 0 + 2^1 + 2^0       3
0100       0 + 2^2 + 0 + 0         4
0101       0 + 2^2 + 0 + 2^0       5
0110       0 + 2^2 + 2^1 + 0       6
0111       0 + 2^2 + 2^1 + 2^0     7 -> the most positive value
1000      -2^3 + 0 + 0 + 0        -8 -> the most negative value
1001      -2^3 + 0 + 0 + 2^0      -7
1010      -2^3 + 0 + 2^1 + 0      -6
1011      -2^3 + 0 + 2^1 + 2^0    -5
1100      -2^3 + 2^2 + 0 + 0      -4
1101      -2^3 + 2^2 + 0 + 2^0    -3
1110      -2^3 + 2^2 + 2^1 + 0    -2
1111      -2^3 + 2^2 + 2^1 + 2^0  -1

Donc, le complément des deux n'est pas un schéma exclusif pour représenter des entiers négatifs, nous pouvons plutôt dire que la représentation binaire des entiers est toujours la même, nous nions simplement le poids du bit le plus significatif. Et que peu détermine le signe de l'entier.

En C, il y a un mot clé unsigned (non disponible en java), qui peut être utilisé pour déclarer unsigned int x;. Dans les entiers non signés, le poids du MSB est positif (2^31) plutôt que étant négatif. Dans ce cas, la portée d'un unsigned int est 0 à 2^32 - 1, tandis que int a range -2^31 à 2^31 - 1.

D'un autre point de vue, si vous considérez le complément des deux de x comme ~x + 1 (PAS x plus UN), Voici l'explication:

, Pour tout x, ~x est juste le bit à bit inverse de x, donc où x est un 1 bits, ~x aura un 0-bits (et vice versa). Donc, si vous les additionnez, il n'y aura pas de report dans l'addition et la somme sera juste un entier dont chaque bit est 1.

Pour les entiers 32 bits:

x + ~x = 1111 1111 1111 1111 1111 1111 1111 1111
x + ~x + 1 =   1111 1111 1111 1111 1111 1111 1111 1111 + 1
           = 1 0000 0000 0000 0000 0000 0000 0000 0000

Le 1-bit le plus à gauche sera simplement ignoré, car il ne correspond pas à 32 bits (dépassement d'entier). Donc,

x + ~x + 1 = 0
-x = ~x + 1

, Donc vous pouvez voir que le négatif x peut être représenté par ~x + 1, que nous appelons le complément à deux de x.

J'ai couru le programme suivant pour le savoir

public class Negative {
    public static void main(String[] args) {
        int i =10;
        int j = -10;

        System.out.println(Integer.toBinaryString(i));
        System.out.println(Integer.toBinaryString(j));
    }
}

La sortie est

1010
11111111111111111111111111110110

De la sortie, il semble qu'il a utilisé le complément de deux.

Oracle fournit une documentation concernant Java Datatypes que vous pouvez trouver intéressante. Plus précisément:

Int: le type de données int est un entier de complément de deux signés 32 bits. Il a une valeur minimale de -2 147 483 648 et une valeur maximale de 2 147 483 647 (inclusivement).

Btw, short est également stocké en tant que complément de deux.

Selon ce document , tous les entiers sont signés et stockés dans le format de complément de deux pour java. Pas certain de sa fiabilité..

Le bit Le plus significatif (32e) indique que le nombre est positif ou négatif. Si c'est 0, cela signifie que le nombre est positif et qu'il est stocké dans sa représentation binaire réelle. mais si c'est 1, cela signifie que le nombre est négatif et est stocké dans la représentation du complément de ses deux. Donc, quand nous donnons du poids -2^32 au 32e bit tout en restaurant la valeur entière à partir de sa représentation binaire, nous obtenons la réponse réelle.

Merci, dreamcrash pour la réponse https://stackoverflow.com/a/13422442/1065835; sur à la page de wiki ils donnent un exemple qui m'a aidé à comprendre comment trouver la représentation binaire de la contrepartie négative d'un nombre positif.

Par exemple, en utilisant 1 octet (=2 nibbles = 8 bits), le nombre décimal 5 est représenté par

0000 01012 le bit le plus significatif est 0, donc le motif représente un non-valeur négative. De convertir en -5 en notation à deux compléments, le les bits sont inversés; 0 devient 1 et 1 devient 0:

1111 1010 à ce stade, le chiffre est le complément de ceux du valeur décimale -5. Pour obtenir le complément des deux, 1 est ajouté au résultat, donnant:

1111 1011 le résultat est un nombre binaire signé représentant valeur décimale -5 sous forme de complément à deux. Le bit le plus significatif est 1, donc la valeur représentée est négative.

Les nombres positifs sont stockés / récupérés tels quels.

e.g) For +ve number 10; byte representation will be like 0-000 0010 
                                               (0 - MSB will represent that it is +ve).
So while retrieving based on MSB; it says it is +ve, 
so the value will be taken as it is. 

Mais les nombres négatifs seront stockés après le complément de 2 (autre que MSB bit), et MSB bit sera défini sur 1.

Par exemple) lors du stockage de -10 alors

  0-000 0010  -> (1's complement) -> 0-111 1101 
              -> (2's complement) 0-111 1101 + 1 -> 0-111 1110
  Now MSB will be set to one, since it is negative no -> 1-111 1110

Lors de la récupération, il a constaté que MSB est défini sur 1. Il est donc négatif non. Et le complément de 2 sera effectué autre que MSB.

  1-111 1110  --> 1-000 0001 + 1 --> 1-000 0010
  Since MSB representing this is negative 10 --> hence  -10 will be retrived.

Casting

Notez également que lorsque vous lancez int/court d'octets, seul le dernier octet sera considéré avec le dernier octet MSB,

Prenez l'exemple "-130" court, il peut être stocké comme ci-dessous

(MSB)1-(2's complement of)130(1000 0010) --> 1-111 1111 0111 1110

Maintenant, la coulée d'octets a pris le dernier octet qui est 0111 1110. (0-MSB) Puisque MSB dit qu'il s'agit d'une valeur +ve, il sera donc pris tel quel. Qui est de 126. (+ve).

Prenez un autre exemple" 130 " court, il pourrait être stocké comme ci-dessous

  0-000 000 1000 0010     (MSB = 0)

Maintenant, la coulée d'octets a pris le dernier octet qui est 1000 0010 . (1 = MSB) Puisque MSB dit que c'est - valeur ve, le complément de 2 sera effectué et le nombre négatif sera retourné. Donc dans ce cas -126 sera retourné.

 1-000 0010  -> (1's complement) -> 1-111 1101 
             -> (2's complement) 1-111 1101 + 1 -> 1-111 1110 -> (-)111 1110
               = -126

Diff entre (int)(char) (octet) -1 et(int)(court) (octet) -1

(byte)-1       -> 0-000 0001 (2's Comp) -> 0-111 1111 (add sign) -> 1-111 1111
(char)(byte)-1 -> 1-111 1111 1111 1111  (sign bit is carry forwarded on left) 

De même

(short)(byte)-1-> 1-111 1111 1111 1111  (sign bit is carry forwarded on left) 

Mais

(int)(char)(byte)-1 -> 0-0000000 00000000 11111111 11111111  = 65535
since char is unsigned; MSB won't be carry forwarded. 

Et

(int)(Short)(byte)-1 -> 1-1111111 11111111 11111111 11111111 = -1
since short is signed; MSB is be carry forwarded. 

Références

Pourquoi le complément de deux est-il utilisé pour représenter des nombres négatifs?

Qu'est-ce que le "complément 2"?

Les nombres positifs sont stockés directement en tant que binaire. Le compliment de 2 est requis pour les nombres négatifs.

Par exemple:

15 : 00000000 00000000 00000000 00001111
-15: 11111111 11111111 11111111 11110001

Voici la différence dans le bit signé.

Pour l'entier positif 2 ' la valeur de complement est la même avec le bit MSB 0 (like +14 2'complement is 01110).

Pour seulement un entier négatif seulement, nous calculons la valeur de 2'complément (-14= 10001+1 = 10010).

Donc la réponse finale est à la fois les valeurs(+ve and -ve) sont stockées sous forme de 2'complément seulement.