18

I've read about overflow, I know that "Overflow is when a number is so large that it will no longer fit within the data type, so the system “wraps around” to the next lowest value and counts up from there".

For example:

short s = (short)1921222; // Stored as 20678

In that example we started counting from -32768 (Short.MIN_VALUE), but when I try to prove in another integer data types, it doesn't seem work the same way...

byte b = (byte)400; // Stored as -112

The example above started counting from 0 that was the only way I found to get -112

I don't know if I am doing something wrong.

mx0
  • 6,445
  • 12
  • 49
  • 54
Luisk4
  • 377
  • 1
  • 5
  • 12
  • 3
    Convert the integer to binary. Only keep the first n-bytes from the right(in little endian) where n is the size of the data type and ignore(truncate) the rest. Convert these bytes to integer again(use 2's complement if needed). – Pushan Gupta Nov 28 '17 at 14:59
  • Apologies in advance for tooting my own horn, but I was just reminded the other day of a similar question I answered a few years ago [regarding `short` overflow specifically](https://stackoverflow.com/questions/11990681/overflowing-short-in-java/11990804#11990804). My answer there contains a specific example, which may help solidify things for you. – yshavit Nov 29 '17 at 05:15

4 Answers4

18

The Java Language Specification says:

The integral types are byte, short, int, and long, whose values are 8-bit, 16-bit, 32-bit and 64-bit signed two's-complement integers, respectively, and char, whose values are 16-bit unsigned integers representing UTF-16 code units.

So, short and byte are both two's complement integers.

short is 16 bits, meaning it can hold 2^16 = 65536 different values. After the 65536th value, it overflows.
1921222 modulo 65536 is 20678 . This is less than 32768 (2^15, the turning point for the two's complement) so we keep a positive number.

byte is 8 bits, meaning it can hold 2^8 = 256 different values. This one overflows after the 256hth value. 400 modulo 256 is 144. This value is higher than 128, the turning point for the two's complement - hence it will be interpreted as a negative two's complement number.

S.L. Barth is on codidact.com
  • 8,198
  • 71
  • 51
  • 66
  • 4
    "`short` is 16 bits, meaning its maximum value is 2^16 = 65536"—this is quite misleading. The value `65536` does not fit in a Java `short`. – wchargin Nov 28 '17 at 18:32
15

The cast is truncating the number. (JLS)

0000 0001 1001 0000

loses the high byte to become

1001 0000

which is -112.

Kylos
  • 1,888
  • 14
  • 24
6

In java, byte primitive type is an 8 bit signed integer, that's why you got -112 from calling:

byte b = (byte) 400;

You can avoid that and get its un-signed value, by binary adding it with 0xFF like this:

int b = (byte) 400 & 0xFF;

For further details you can check:

cнŝdk
  • 31,391
  • 7
  • 56
  • 78
4

In addition to the other answers, you can get to that answer by manual calculation as well.

In Java, the data type byte is an 8-bit, signed integer. So the values are in the interval [-128, 127]. If you have a value of 400 and you want to see the actual value for that type, you can subtract the size of the interval from that number until you reach a value that's inside the interval.

As I said, byte is 8 bit, so the size of the interval is 256. Subtract that from your initial value: 400 - 256 = 144. This value is still outside of the interval so you have to subtract again: 144 - 256 = -112. This value is now inside the interval and is indeed the value you've seen in your test.

The same is true for your first example: short is 16 bit and signed, so the interval is [-32768, 32767] with size 65536. Doing repeated subtraction from the value 1921222 will eventually give you the value 20678 as seen in your test.

QBrute
  • 4,405
  • 6
  • 34
  • 40