# Tutorial :How does Java convert int into byte? ### Question:

``int i =132;  byte b =(byte)i;  System.out.println(b);  ``

The output is -124

Why is that? I know this is a very basic question, but I'm still not able to map it, or understand how this happens?

### Solution:1

In Java, an `int` is 32 bits. A `byte` is 8 `bits` .

Everything in Java is signed, and `byte`s, `int`s, `long`s are encoded in two's complement.

In this numberscheme the most significant bit specifies the sign of the number. If more bits are needed, the most significant bit ("MSB") is simply copied to the new MSB.

So if you have byte `255`: `11111111` and you want to represent it as an `int` (32 bits) you simply copy the 1 to the left 24 times.

Now, one way to read a negative two's complement number is to start with the least significant bit, move left until you find the first 1, then invert every bit afterwards. The resulting number is the positive version of that number

For example: `11111111` goes to `00000001` = `-1`. This is what Java will display as the value.

What you probably want to do is know the unsigned value of the byte.

You can accomplish this with a bitmask that deletes everything but the least significant 8 bits. (0xff)

So:

``byte signedByte = -1;  int unsignedByte = signedByte & (0xff);    System.out.println("Signed: " + signedByte + " Unsigned: " + unsignedByte);  ``

Would print out: `"Signed: -1 Unsigned: 255"`

What's actually happening here?

We are using bitwise AND to mask all of the extraneous sign bits (the 1's to the left of the least significant 8 bits.) When an int is converted into a byte, Java chops-off the left-most 24 bits

``1111111111111111111111111010101  &  0000000000000000000000001111111  =  0000000000000000000000001010101  ``

Since the 32nd bit is now the sign bit instead of the 8th bit (and we set the sign bit to 0 which is positive), the original 8 bits from the byte are read by Java as a positive value.

### Solution:2

To understand how it works, we need to know that computers work in bits.

132 in base 10 (decimal) is `10000100` in base 2 (binary). Since Java stores `int` in 32 bits, what we have is

`00000000_00000000_00000000_10000100`

When an `int` is converted into a `byte`, Java chops-off the left-most 24 bits. What we get is `10000100`.

In two's complement, the left-most bit is used as the sign. If the left-most bit is `0`, nothing further will be done.

If the left-most bit is `1` (as we have here), it means that the number is negative and more work needs to be done. To get the magnitude, we minus one then apply one's complement (apply one's complement means we invert the bits):

1. `10000100` - 1 = `10000011`

2. Invert `10000011` = `01111100`

`01111100` when interpreted as a decimal number, is 124.

So we have a negative number with a magnitude of 124, giving us -124.

### Solution:3

byte in Java is signed, so it has a range -2^7 to 2^7-1 - ie, -128 to 127. Since 132 is above 127, you end up wrapping around to 132-256=-124. That is, essentially 256 (2^8) is added or subtracted until it falls into range.

For more information, you may want to read up on two's complement.

### Solution:4

132 is outside the range of a byte which is -128 to 127 (Byte.MIN_VALUE to Byte.MAX_VALUE) Instead the top bit of the 8-bit value is treated as the signed which indicates it is negative in this case. So the number is 132 - 256 = -124.

### Solution:5

often in books you will find the explanation of casting from int to byte as being performed by modulus division. this is not strictly correct as shown below what actually happens is the 24 most significant bits from the binary value of the int number are discarded leaving confusion if the remaining leftmost bit is set which designates the number as negative

``public class castingsample{    public static void main(String args[]){        int i;      byte y;      i = 1024;      for(i = 1024; i > 0; i-- ){          y = (byte)i;        System.out.print(i + " mod 128 = " + i%128 + " also ");        System.out.println(i + " cast to byte " + " = " + y);        }    }    }  ``

### Solution:6

here is a very mechanical method without the distracting theories:

1. Convert the number into binary representation (use a calculator ok?)
2. Only copy the rightmost 8 bits (LSB) and discard the rest.
3. From the result of step#2, if the leftmost bit is 0, then use a calculator to convert the number to decimal. This is your answer.
4. Else (if the leftmost bit is 1) your answer is negative. Leave all rightmost zeros and the first non-zero bit unchanged. And reversed the rest, that is, replace 1's by 0's and 0's by 1's. Then use a calculator to convert to decimal and append a negative sign to indicate the value is negative.

This more practical method is in accordance to the much theoretical answers above. So, those still reading those Java books saying to use modulo, this is definitely wrong since the 4 steps I outlined above is definitely not a modulo operation.

### Solution:7

Two's complement Equation: In Java, `byte` (N=8) and `int` (N=32) are represented by the 2s-complement shown above.

From the equation, a7 is negative for `byte` but positive for `int`.

``coef:   a7    a6  a5  a4  a3  a2  a1  a0  Binary: 1     0   0   0   0   1   0   0  ----------------------------------------------  int:    128 + 0 + 0 + 0 + 0 + 4 + 0 + 0 =  132  byte:  -128 + 0 + 0 + 0 + 0 + 4 + 0 + 0 = -124  ``

### Solution:8

A quick algorithm that simulates the way that it work is the following:

``public int toByte(int number) {      int tmp = number & 0xff      return (tmp & 0x80) == 0 ? tmp : tmp - 256;  }  ``

How this work ? Look to daixtr answer. A implementation of exact algorithm discribed in his answer is the following:

``public static int toByte(int number) {      int tmp = number & 0xff;      if ((tmp & 0x80) == 0x80) {          int bit = 1;          int mask = 0;          for(;;) {              mask |= bit;              if ((tmp & bit) == 0) {                  bit <<=1;                  continue;              }              int left = tmp & (~mask);              int right = tmp & mask;              left = ~left;              left &= (~mask);              tmp = left | right;              tmp = -(tmp & 0xff);              break;          }      }      return tmp;  }  ``

### Solution:9

Conceptually, repeated subtractions of 256 are made to your number, until it is in the range -128 to +127. So in your case, you start with 132, then end up with -124 in one step.

Computationally, this corresponds to extracting the 8 least significant bits from your original number. (And note that the most significant bit of these 8 becomes the sign bit.)

Note that in other languages this behaviour is not defined (e.g. C and C++).

### Solution:10

`` N is input number  case 1: 0<=N<=127  answer=N;  case 2: 128<=N<=256 answer=N-256   case 3: N>256             temp1=N/256;          temp2=N-temp*256;          if temp2<=127   then answer=temp2;          else if temp2>=128  then answer=temp2-256;  case 4: negative  number input          do same procedure.just change the sign of the solution             ``

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Previous
Next Post »