Java 中的 byte 是有符号的 8 位整数（范围：-128 到 127），当从 int 转换为 byte 时，只会保留最低的 8 位，并且会进行符号扩展。

下面我们详细分解这两种转换。

int 转 byte

这是最需要注意转换逻辑的地方，因为 int 是 32 位，而 byte 是 8 位,所以直接转换会截断高位数据。

方法：强制类型转换 (Casting)

使用 (byte) 进行强制转换。

转换规则：

1. 截断：只保留 int 数值的最低 8 位（也就是最后一个字节）。
2. 符号扩展：如果被截断的最高位（第 8 位）是 1，那么转换后的 byte 值就是负数，Java 会自动处理这种从高精度到低精度的有符号转换。

示例代码

public class IntToByteConversion {
    public static void main(String[] args) {
        // --- 情况一：在 byte 范围内的正数 ---
        int int1 = 65;
        byte byte1 = (byte) int1;
        System.out.println("int: " + int1 + " -> byte: " + byte1); // 输出: int: 65 -> byte: 65
        System.out.println("int1 的二进制: " + Integer.toBinaryString(int1)); // ... 1000001 (实际上有24个0在前)
        System.out.println("byte1 的二进制: " + Integer.toBinaryString(byte1 & 0xFF)); // 01000001 (使用 & 0xFF 可以看到无符号的8位表示)
        System.out.println("------------------------------------");
        // --- 情况二：在 byte 范围内的负数 ---
        int int2 = -50;
        byte byte2 = (byte) int2;
        System.out.println("int: " + int2 + " -> byte: " + byte2); // 输出: int: -50 -> byte: -50
        System.out.println("------------------------------------");
        // --- 情况三：超出 byte 正数范围 (大于 127) ---
        int int3 = 200;
        byte byte3 = (byte) int3;
        // 200 的二进制是 11001000，截断后是 11001000。
        // 因为最高位是1，这是一个负数，它的值是 -128 + 64 + 16 = -48。
        System.out.println("int: " + int3 + " -> byte: " + byte3); // 输出: int: 200 -> byte: -48
        System.out.println("------------------------------------");
        // --- 情况四：超出 byte 负数范围 (小于 -128) ---
        int int4 = -130;
        byte byte4 = (byte) int4;
        // -130 的二进制（补码）是 ... 11111110 01111110，截断后是 01111110。
        // 因为最高位是0，这是一个正数，它的值是 126。
        System.out.println("int: " + int4 + " -> byte: " + byte4); // 输出: int: -130 -> byte: 126
        System.out.println("------------------------------------");
    }
}

int 转 byte：

• 直接强制转换 (byte) myInt 是标准做法。
• 关键是理解截断和符号扩展，如果原始 int 值在 byte 范围内（-128 到 127），转换后值不变，如果超出，结果会“回绕”。

byte 转 int

这个转换相对简单，因为 int 的范围比 byte 大得多，但同样，因为 byte 是有符号的,所以需要考虑如何处理符号。

方法 1：隐式转换 (自动类型提升)

这是最简单、最常用的方法，当 byte 被用在需要 int 的上下文中时，Java 会自动将其提升为 int。

转换规则：

• 符号扩展：byte 的符号位（最高位）会被复制到 int 的高 24 位上,这样可以保证数值的符号和大小不变。

byte myByte = -50;
int myInt = myByte; // 隐式转换
System.out.println("byte: " + myByte + " -> int: " + myInt); // 输出: byte: -50 -> int: -50

方法 2：显式转换 (强制类型转换)

虽然隐式转换已经足够，但你也可以使用 (int) 进行显式转换,效果与隐式转换完全相同。

byte myByte = 65;
int myInt = (int) myByte;
System.out.println("byte: " + myByte + " -> int: " + myInt); // 输出: byte: 65 -> int: 65

特殊情况：将 byte 视为无符号整数

在某些场景下（例如读取网络数据包的头部），你希望将一个 byte 的值（0xFF）当作一个 0 到 255 之间的无符号整数来处理。

直接转换会得到负数：

byte unsignedByte = (byte) 0xFF; // 0xFF 的二进制是 11111111，作为有符号byte是 -1
int signedInt = unsignedByte;    // 输出 -1

如何正确地转换为无符号 int？ 你需要使用位运算 & 0xFF 来屏蔽掉高 24 位，确保结果是一个 0 到 255 之间的正数。

byte unsignedByte = (byte) 0xFF; // 这个byte的值是 -1
// 错误的方式：得到有符号值
int signedInt = unsignedByte; // 结果是 -1
// 正确的方式：得到无符号值 (0-255)
int unsignedInt = unsignedByte & 0xFF;
// 解释：
// 1. unsignedByte (作为int扩展后) 是 11111111 11111111 11111111 11111111
// 2. 0xFF 的二进制是 00000000 00000000 00000000 11111111
// 3. 按位与后，高24位被清零，低8位保持不变。
// 4. 结果是 00000000 00000000 00000000 11111111，即十进制的 255。
System.out.println("Byte value: " + unsignedByte); // 输出: -1
System.out.println("Signed int: " + signedInt);    // 输出: -1
System.out.println("Unsigned int: " + unsignedInt); // 输出: 255

完整示例与最佳实践

public class IntByteExample {
    public static void main(String[] args) {
        // --- int 转 byte ---
        System.out.println("--- int to byte ---");
        int intValue = 300;
        byte byteValue = (byte) intValue; // 强制转换
        System.out.printf("int %d (0x%X) -> byte %d (0x%X)%n", intValue, intValue, byteValue, byteValue);
        // --- byte 转 int (有符号) ---
        System.out.println("\n--- byte to int (signed) ---");
        byte signedByte = (byte) 0xAB; // 0xAB = 171, 但作为有符号byte是 -85
        int signedInt = signedByte;    // 隐式转换
        System.out.printf("byte 0x%X (%d) -> int %d (0x%X)%n", signedByte, signedByte, signedInt, signedInt);
        // --- byte 转 int (无符号) ---
        System.out.println("\n--- byte to int (unsigned) ---");
        byte unsignedByte = (byte) 0xAB; // 这个byte的值是 -85
        int unsignedInt = unsignedByte & 0xFF; // 使用 & 0xFF 得到无符号值
        System.out.printf("byte 0xX (%d) -> unsigned int %d (0xX)%n", unsignedByte, unsignedByte, unsignedInt, unsignedInt);
    }
}

输出结果：

--- int to byte ---
int 300 (0x12C) -> byte 44 (0x2C)
--- byte to int (signed) ---
byte 0xAB (-85) -> int -85 (0xFFFFFFAB)
--- byte to int (unsigned) ---
byte 0xAB (-85) -> unsigned int 171 (0xAB)