W jaki sposób liczby całkowite są wewnętrznie reprezentowane na poziomie bitów w Javie?

Liczby całkowite Javy są 32-bitowe i zawsze podpisane. Oznacza to, że najbardziej znaczący bit (MSB) działa jako bit znaku. Liczba całkowita reprezentowana przez int jest niczym innym jak ważoną sumą bitów. Wagi są przypisane w następujący sposób:

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

Zauważ, że waga MSB jest ujemna (największa możliwa ujemna w rzeczywistości), więc gdy ten bit jest włączony, liczba całkowita (suma ważona) staje się ujemna.

Let ' s simulate it with 4-bit liczby:

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

Zatem dopełnienie tych dwóch rzeczy nie jest wyłącznym schematem przedstawiania ujemnych liczb całkowitych, raczej możemy powiedzieć, że binarna reprezentacja liczb całkowitych jest zawsze taka sama, po prostu negujemy wagę najbardziej znaczącego bitu. I ten bit określa znak liczby całkowitej.

W języku C istnieje słowo kluczowe unsigned (niedostępne w Javie), które może być użyte do zadeklarowania unsigned int x;. W niepodpisanych liczbach całkowitych masa MSB jest dodatnia (2^31), a nie bycie negatywnym. W tym przypadku zakres unsigned int wynosi 0 do 2^32 - 1, podczas gdy int mA Zakres -2^31 do 2^31 - 1.

Z innego punktu widzenia, jeśli rozważysz dopełniacz x jako ~x + 1 (nie x plus jeden), oto Wyjaśnienie:

Dla każdego x, ~x jest tylko bitową odwrotnością x, więc gdziekolwiek x mA 1-bit, ~x będzie miał 0-bit tam (i vice versa). Tak więc, jeśli dodasz je, nie będzie przenoszenia w dodatku i suma będzie tylko liczbą całkowitą, której każdy bit jest 1.

Dla 32-bitowych liczb całkowitych:

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

Lewy 1-bit zostanie po prostu odrzucony, ponieważ nie mieści się w 32-bitach (integer overflow).

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

Więc widać, że negatyw x Może być reprezentowany przez ~x + 1, które nazywamy dopełnieniem obu x.

Uruchomiłem następujący program, aby go poznać

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));
    }
}

Wyjście To

1010
11111111111111111111111111110110

Z wyjścia wynika, że używa dopełniacza two.

Oracle dostarcza pewną dokumentację dotyczącą typów danych Java , która może Cię zainteresować. Konkretnie:

Int: typ danych int jest 32-bitową, podpisaną liczbą całkowitą dopełniacza dwójki. Ma minimalną wartość -2,147,483,648 i maksymalną wartość 2,147,483,647 (włącznie).

Btw, short jest również zapisywany jako dopełnienie dwójki.

Zgodnie z ten dokument , wszystkie liczby całkowite są podpisane i przechowywane w formacie uzupełniającym two dla Javy. Nie jestem pewien jego wiarygodności..

Najbardziej znaczący bit (32nd) wskazuje, że liczba jest dodatnia lub ujemna. Jeśli jest to 0, oznacza to, że liczba jest dodatnia i jest przechowywana w jej rzeczywistej reprezentacji binarnej. ale jeśli jest 1, oznacza to, że liczba jest ujemna i jest przechowywana w reprezentacji dopełniacza jej dwóch. Tak więc, gdy podamy wagę -2^32 do 32-go bitu, przywracając wartość całkowitą z jego binarnej reprezentacji, otrzymujemy rzeczywistą odpowiedź.

Thank you, dreamcrash for The answer https://stackoverflow.com/a/13422442/1065835 ; na stronie wiki dają przykład, który pomógł mi zrozumieć, jak znaleźć binarną reprezentację negatywnego odpowiednika liczby dodatniej.

Na przykład, używając 1 bajtu (=2 bajty = 8 bitów), liczba dziesiętna 5 jest reprezentowany przez

0000 01012 najbardziej znaczącym bitem jest 0, więc wzór reprezentuje wartość nieujemna. Na przeliczyć na -5 w notacji dopełniacza dwójkowego, czyli bity są odwrócone; 0 staje się 1, A 1 staje się 0:

1111 1010 wartość dziesiętna -5. Aby otrzymać dopełnienie dwóch, dodaje się 1 do wynik, dając:

1111 1011 wynikiem jest podpisana liczba binarna reprezentująca wartość dziesiętna -5 w postaci dopełniacza dwójki. Najbardziej znaczącym bitem jest 1, więc reprezentowana wartość jest ujemna.

Liczby dodatnie są przechowywane / pobierane tak, jak jest.

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. 

Ale liczby ujemne będą zapisywane po dopełniaczu 2 (innym niż Bit MSB), a bit MSB zostanie ustawiony na 1.

Np. podczas przechowywania -10 wtedy

  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

Podczas pobierania okazało się, że MSB jest ustawione na 1. Więc to jest negatywne nie. Dopełnienie 2 będzie wykonywane inaczej niż MSB.

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

Casting

Zauważ również, że podczas castingu int / short to byte, tylko ostatni bajt będzie brany pod uwagę wraz z ostatnim bajtem MSB,

Weźmy przykład "-130" w skrócie, może być przechowywany jak poniżej

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

Teraz casting bajtów wziął ostatni bajt, który jest 0111 1110. (0-MSB) Ponieważ MSB mówi, że jest to wartość + ve, więc zostanie ona przyjęta tak, jak jest. Czyli 126. (+ve).

Weźmy inny przykład " 130 " W skrócie, może być przechowywany jak poniżej

  0-000 000 1000 0010     (MSB = 0)

Teraz casting bajtów wziął ostatni bajt, który wynosi 1000 0010 . (1=MSB) Skoro MSB mówi, że jest - wartość ve, zostanie wykonane dopełnienie 2 i zostanie zwrócona liczba ujemna. Tak więc w tym przypadku -126 zostanie zwrócone.

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

Różnica pomiędzy (int)(char) (byte) -1 i (int) (short) (byte) -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) 

Podobnie

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

Ale

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

I

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

Referencje

Dlaczego dopełniacz two jest używany do reprezentowania liczb ujemnych?

Co To jest "dopełnienie 2"?

Liczby dodatnie są zapisywane bezpośrednio jako binarne. Komplement 2 jest wymagany dla liczb ujemnych.

Na przykład:

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

Oto różnica w podpisanym bitie.

Dla dodatniej liczby całkowitej 2 ' jest taka sama dla bitu MSB 0 (like +14 2'complement is 01110).

Tylko dla ujemnej liczby całkowitej obliczamy wartość 2 ' (-14= 10001+1 = 10010).

Więc ostateczną odpowiedzią jest to, że obie wartości (+ve and -ve) są przechowywane tylko w postaci 2'.