Java将int转换为byte时的奇怪行为？

令人难以置信。为什么输出

-124

？

字节在Java中是有符号的，所以它的范围是-2^7到2^7-1-ie，-128到127。 由于132高于127，因此最终将换行到132-256=-124。也就是说，基本上256（2^8）被加或减，直到它进入范围

---

有关详细信息，请阅读。

Java中的字节是有符号的，因此它的范围为-2^7到2^7-1-ie，-128到127。 由于132高于127，因此最终将换行到132-256=-124。也就是说，基本上256（2^8）被加或减，直到它进入范围

---

有关详细信息，您可能需要阅读。

132超出了-128到127（byte.MIN\u值到byte.MAX\u值）的字节范围

---

相反，8位值的顶部位被视为有符号，这表明在这种情况下它是负数。因此，数字是132-256=-124。

132超出了-128到127（byte.MIN\u值到byte.MAX\u值）的字节范围

---

相反，8位值的顶部位被视为有符号，这表明在这种情况下它是负数。所以这个数字是132-256=-124。

在Java中，int是32位的。一个

字节

是8个

位

Java中的大多数基元类型都是有符号的，

byte

、

short

、

int

和

long

都是以二的补码编码的。（字符类型是无符号的，

char

，符号的概念不适用于

boolean

）

在此数字方案中，最高有效位指定数字的符号。如果需要更多位，则将最高有效位（“MSB”）简单地复制到新的MSB

因此，如果您有字节

255

：

11111111

如果您想将其表示为

int

（32位），只需将1向左复制24次

现在，读取负2的补码的一种方法是从最低有效位开始，向左移动，直到找到第一个1，然后将每个位反转。结果数字是该数字的正版本

例如：

11111111

转到

00000001

=

-1

。这就是Java将显示为值的内容

您可能需要知道字节的无符号值

您可以使用位掩码来完成此操作，该位掩码删除除最低有效8位以外的所有内容。（0xff）

因此：

将打印出：

“已签名：-1未签名：255”

这里到底发生了什么

我们使用按位AND来屏蔽所有无关的符号位（最低有效8位左侧的1） 当一个int转换成一个字节时，Java将去掉最左边的24位

byte signedByte = -1;
int unsignedByte = signedByte & (0xff);

System.out.println("Signed: " + signedByte + " Unsigned: " + unsignedByte);

---

由于第32位现在是符号位，而不是第8位（我们将符号位设置为0，这是正数），因此Java将字节中的原始8位读取为正值

在Java中，

int

是32位。一个

字节

是8个

位

Java中的大多数基元类型都是有符号的，

byte

、

short

、

int

和

long

都是以二的补码编码的。（字符类型是无符号的，

char

，符号的概念不适用于

boolean

）

在此数字方案中，最高有效位指定数字的符号。如果需要更多位，则将最高有效位（“MSB”）简单地复制到新的MSB

因此，如果您有字节

255

：

11111111

如果您想将其表示为

int

（32位），只需将1向左复制24次

现在，读取负2的补码的一种方法是从最低有效位开始，向左移动，直到找到第一个1，然后将每个位反转。结果数字是该数字的正版本

例如：

11111111

转到

00000001

=

-1

。这就是Java将显示为值的内容

您可能需要知道字节的无符号值

您可以使用位掩码来完成此操作，该位掩码删除除最低有效8位以外的所有内容。（0xff）

因此：

将打印出：

“已签名：-1未签名：255”

这里到底发生了什么

我们使用按位AND来屏蔽所有无关的符号位（最低有效8位左侧的1） 当一个int转换成一个字节时，Java将去掉最左边的24位

byte signedByte = -1;
int unsignedByte = signedByte & (0xff);

System.out.println("Signed: " + signedByte + " Unsigned: " + unsignedByte);

---

由于第32位现在是符号位，而不是第8位（我们将符号位设置为0，这是正数），因此Java将字节中的原始8位读取为正值

132

位（）是

1000\u 0100

位（），Java存储

int

是32位：

1111111111111111111111111010101
&
0000000000000000000000001111111
=
0000000000000000000000001010101

0000_0000_0000_0000_0000_0000_1000_0100 整数到字节的算法是左截断；

System.out.println

的算法是（如果最左边的位是

1

，则表示为负数（反转位）减去一）；因此，

System.out.println（int到byte（

）

是：

• 解释为（if-leftmost-bit-is-1[负（反转位（负一（]左截断（

  0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_1000_0100

  ）[）））
• =解释为（if-leftmost-bit-is-1[负（反转位（负一）（]））
• =解释为（负（反转位（负一（

  10000100

  ））
• =解释为（负（反转位（

  10000011

  ））
• =解释为（否定（

  0111\u 1100

  ）
• =解释为（否定（124））
• =解释为（-124）
• =-124塔达

  ---

132

数字（）是

1000\u 0100

位（），Java存储

int

是32位：

1111111111111111111111111010101
&
0000000000000000000000001111111
=
0000000000000000000000001010101

0000_0000_0000_0000_0000_0000_1000_0100 整数到字节的算法是左截断；

System.out.println的算法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);

    }

}

}

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

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

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

 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           

double a = 295.04;
int b = 300;
byte c = (byte) a;
byte d = (byte) b; System.out.println(c + " " + d);

            000 0010   
          -------------
            111 1101
       add         1
          -------------
            111 1110 =126

        111 0100
      -------------
        000 1011 
    add        1
      -------------
        000 1100 =12

 300=1 0010 1100

 1st 7 bits =010 1100

 remaining bit is '0' sign =+ve need not take 2's compliment for +ve sign

 hence 010 1100 =44

 byte(300) =44