用Java转换不兼容的类型

Question

While going through the theory I came across this line which I don't understand. "If integer's value is larger than the range of byte, it will be reduced modulo (the remainder of an integer division by the) bytes range."

What does this statement mean? I know that range of integer is much greater than the range of byte. Can someone explain? PS : I am a beginner in programming. Thanks

Answer 1

Modulo ( % ) means remainder after clean division. Such as 5 % 2 == 1

Therefore, if you are trying to create a byte out of an int and it is larger than the max range of the byte , it will divide by the max value of byte and give you the remainder as the byte 's value.

Example:

int a = 300 //The max value of a Byte is 256

byte b = (byte)a; //cast it to a byte, so take the remainder of 300 / 256.

//This produces 300 % 256, which is equal to 34.

Answer 2

There is no modulo actually. Narrowing conversion in Java cuts bits (byte is 8 bit value, integer is 32 bit). So I made an example of byte conversion:

int[] values = new int[]{ 300, 128, -1, -129, -4097};

for(int i : values) {
    String intValue = Integer.toString(i);
    String intBinary = Integer.toBinaryString(i);
    String byteValue = Byte.toString((byte) i);
    String byteBinary = intBinary.substring(intBinary.length() - 8);

    System.out.println("==============");
    System.out.println("Int val: " + intValue);
    System.out.println("Int bin: " + intBinary);
    System.out.println("Byte val: " + byteValue);
    System.out.println("Byte bin: " + byteBinary);
}

The output is pretty unexpected if you think about modulo (the 128 is my favourite). Remember that the first bit decides whether the number is positive or negativ, but it is also a part of value (that is why byte range is 127 to -128).

==============
Int val: 300
Int bin: 100101100
Byte val: 44
Byte bin: 00101100
==============
Int val: 128
Int bin: 10000000
Byte val: -128
Byte bin: 10000000
==============
Int val: -1
Int bin: 11111111111111111111111111111111
Byte val: -1
Byte bin: 11111111
==============
Int val: -129
Int bin: 11111111111111111111111101111111
Byte val: 127
Byte bin: 01111111
==============
Int val: -4097
Int bin: 11111111111111111110111111111111
Byte val: -1
Byte bin: 11111111

Modulo thing is accurate if we operate on values over or equal 256.