How is 0x80000000 equated to -2147483648 in java?

Question

Taking the binary of 0x80000000 we get

1000 0000 0000 0000 0000 0000 0000 0000

How does this equate to -2147483648. I got this question with this program.

class a
{
        public static void main(String[] args)
        {
                int a = 0x80000000;
                System.out.printf("%x %d\n",a,a);
        }
}

meow@VikkyHacks:~/Arena/java$ java a
80000000 -2147483648

EDIT I learned that 2's complement is used to represent negative numbers. When I try to equate this with that 1's complement would be

1's Comp. :: 0111 1111 1111 1111 1111 1111 1111 1111
2's Comp. :: 1000 0000 0000 0000 0000 0000 0000 0000

which again does not make any sense, How does 0x80000000 equate to -2147483648

Answer 1

This is what happens with signed integer overflow, basically.

It's simpler to take byte as an example. A byte value is always in the range -128 to 127 (inclusive). So if you have a value of 127 (which is 0x7f) if you add 1, you get -128. That's also what you get if you cast 128 (0x80) to byte:

int x = 0x80; // 128
byte y = (byte) x; // -128

Overflow (in 2s complement integer representations) always goes from the highest expressible number to the lowest one.

For unsigned types, the highest value overflows to 0 (which is again the lowest expressible number). This is harder to show in Java as the only unsigned type is char:

char x = (char) 0xffff;
x++;
System.out.println((int) x); // 0

Answer 2

This is the case when there is overflow, with respect to the range of a data type. Here is an example that I can share.

int number = 0x80; // 0x80 is hexadecimal for 128 (decimal)
byte castedNumber = (byte)(number); // On casting, there is overflow,as byte ranges from -128 to 127 (inclusive).
System.out.println(castedNumber); //Output is -128.

Answer 3

Integer range for java is -2,147,483,648 to 2,147,483,647 The given is hex val 0x80000000 its equivalent decimal value is 2,147,483,648(1's complement conversion). You can see the decimal value is not fit within the range which is called Integer overflow. Whenever overflow happens it circles itself to the other end in this case -2,147,483,648.