1. byte 是 8 位有符号整数，范围是 -128 到 127。
2. int 是 32 位有符号整数，范围是 -2,147,483,648 到 2,147,483,647。
3. 由于 int 的范围比 byte 大，所以从 byte 转换到 int 是安全的（不会丢失数值），但从 int 转换到 byte 是不安全的（可能会丢失数值或改变符号），因此需要显式转换。

byte 转 int (byte to int)

当将一个 byte 值赋给一个 int 类型的变量时，Java 会自动进行扩展转换（Widening Conversion），这个转换是隐式的，不需要你手动写任何代码。

byte 只有 8 位，而 int 有 32 位，转换时，Java 会保持 byte 的原始数值和符号，并在高位（左侧）填充1或0，使其成为一个 32 位的 int 值，这个过程被称为符号扩展（Sign Extension）。

• byte 是正数（最高位是 0），高位填充 0。
• byte 是负数（最高位是 1），高位填充 1。

示例代码

public class ByteToIntExample {
    public static void main(String[] args) {
        byte b1 = 10;      // 正数
        byte b2 = -10;     // 负数
        // 隐式转换，无需强制类型转换
        int i1 = b1;
        int i2 = b2;
        System.out.println("原始 byte b1: " + b1);
        System.out.println("转换后的 int i1: " + i1);
        System.out.println("二进制 b1: " + Integer.toBinaryString(b1 & 0xFF)); // & 0xFF 是为了显示无符号8位
        System.out.println("二进制 i1: " + Integer.toBinaryString(i1));
        System.out.println("---------------------------------");
        System.out.println("原始 byte b2: " + b2);
        System.out.println("转换后的 int i2: " + i2);
        System.out.println("二进制 b2: " + Integer.toBinaryString(b2 & 0xFF)); // & 0xFF 是为了显示无符号8位
        System.out.println("二进制 i2: " + Integer.toBinaryString(i2));
    }
}

输出结果分析

原始 byte b1: 10
转换后的 int i1: 10
二进制 b1: 00001010
二进制 i1: 00000000000000000000000000001010
---------------------------------
原始 byte b2: -10
转换后的 int i2: -10
二进制 b2: 11110110
二进制 i2: 11111111111111111111111111110110

从输出可以清楚地看到：

• b1 (10) 的二进制是 00001010，转换成 int 后，前面补了 24 个 0，变成了 ..00001010，数值仍然是 10。
• b2 (-10) 的二进制是 11110110，因为它是负数，转换成 int 后，前面补了 24 个 1，变成了 ..11110110，其补码表示的十进制值仍然是 -10。

int 转 byte (int to byte)

当将一个 int 值赋给一个 byte 类型的变量时，由于 byte 的范围更小，可能会丢失数据，Java 要求你必须进行显式类型转换，也称为收缩转换（Narrowing Conversion），你需要使用强制类型转换符 (byte)。

转换的规则很简单：截断。int 的 32 位二进制表示中，只保留最低的 8 位，并将其作为 byte 的值。

这可能会导致两种情况：

1. 数值截断：int 的值超出了 byte 的范围（-128 到 127），低 8 位代表的数值会与原始 int 值不同。
2. 符号改变：如果被截断后的 8 位最高位是 1，那么这个 byte 值就是负数，即使原始 int 值是正数。

示例代码

public class IntToByteExample {
    public static void main(String[] args) {
        int i1 = 130;      // 超出 byte 范围
        int i2 = -130;     // 超出 byte 范围
        int i3 = 65;       // 在 byte 范围内
        // 必须使用强制类型转换 (byte)
        byte b1 = (byte) i1;
        byte b2 = (byte) i2;
        byte b3 = (byte) i3;
        System.out.println("原始 int i1: " + i1);
        System.out.println("转换后的 byte b1: " + b1);
        System.out.println("二进制 i1: " + Integer.toBinaryString(i1));
        System.out.println("二进制 b1 (低8位): " + Integer.toBinaryString(b1 & 0xFF));
        System.out.println("---------------------------------");
        System.out.println("原始 int i2: " + i2);
        System.out.println("转换后的 byte b2: " + b2);
        System.out.println("二进制 i2: " + Integer.toBinaryString(i2));
        System.out.println("二进制 b2 (低8位): " + Integer.toBinaryString(b2 & 0xFF));
        System.out.println("---------------------------------");
        System.out.println("原始 int i3: " + i3);
        System.out.println("转换后的 byte b3: " + b3);
        System.out.println("二进制 i3: " + Integer.toBinaryString(i3));
        System.out.println("二进制 b3 (低8位): " + Integer.toBinaryString(b3 & 0xFF));
    }
}

输出结果分析

原始 int i1: 130
转换后的 byte b1: -126
二进制 i1: 10000010
二进制 b1 (低8位): 10000010
---------------------------------
原始 int i2: -130
转换后的 byte b2: 126
二进制 i2: 11111111111111111111111101111110
二进制 b2 (低8位): 01111110
---------------------------------
原始 int i3: 65
转换后的 byte b3: 65
二进制 i3: 1000001
二进制 b3 (低8位): 01000001

从输出可以清楚地看到：

1. i1 (130) -> b1 (-126):

   • 130 的二进制是 10000010，这个 8 位模式在 byte 中表示一个负数（补码），计算其值：-(128 - 2) = -126，数值和符号都改变了。

2. i2 (-130) -> b2 (126):

   • -130 的 32 位二进制是 11111111 11111111 11111111 01111110。
   • 只保留低 8 位，得到 01111110。
   • 01111110 是一个正数，其值为 126，符号改变了。

3. i3 (65) -> b3 (65):

   • 65 的二进制是 1000001，补足 8 位是 01000001。
   • 这个 8 位模式在 byte 中表示 65，数值和符号都保持不变。

特殊情况：字节数组与 int 的转换

在网络编程或文件 I/O 中，我们经常需要将 int（通常是 4 字节）转换成 4 个 byte 的数组，或者反之，这不能直接使用 (byte) 强制转换，而需要按位操作。

int 转 byte[] (4 bytes)

public class IntToByteArray {
    public static void main(String[] args) {
        int number = 0x12345678; // 一个32位的整数
        // 创建一个长度为4的字节数组
        byte[] byteArray = new byte[4];
        // 使用 >>> (无符号右移) 和 & (位与) 来提取每个字节
        // 注意：Java中 byte 是有符号的，所以需要 & 0xFF 来得到无符号的值
        byteArray[0] = (byte) ((number >>> 24) & 0xFF); // 最高8位
        byteArray[1] = (byte) ((number >>> 16) & 0xFF);
        byteArray[2] = (byte) ((number >>> 8)  & 0xFF);
        byteArray[3] = (byte) ( number        & 0xFF); // 最低8位
        // 打印结果
        for (byte b : byteArray) {
            System.out.printf("%02X ", b); // %02X 表示两位十六进制，大写
        }
        // 预期输出: 12 34 56 78
    }
}

byte[] 转 int

public class ByteArrayToInt {
    public static void main(String[] args) {
        byte[] byteArray = {0x12, 0x34, 0x56, 0x78}; // 假设这是大端序
        // 将每个字节左移到正确的位置，然后使用 | (位或) 合并
        int number = 0;
        number |= (byteArray[0] & 0xFF) << 24; // 最高8位移到最高8位
        number |= (byteArray[1] & 0xFF) << 16;
        number |= (byteArray[2] & 0xFF) << 8;
        number |= (byteArray[3] & 0xFF);       // 最低8位不动
        System.out.println("转换后的 int: " + Integer.toHexString(number));
        // 预期输出: 12345678
    }
}

注意：上面的例子是基于大端序（Big-Endian）的，即最高有效字节在数组的最前面，网络协议（如 TCP/IP）通常使用大端序，如果你处理的是小端序（Little-Endian），字节的顺序需要反过来。