数据类型范围

要理解转换,必须知道它们的数据范围：

• byte: 8位（1字节），有符号，范围是 -128 到 127。
• int: 32位（4字节），有符号，范围是 -2,147,483,648 到 2,147,483,647。

因为 int 的范围远大于 byte，所以它们之间的转换不是完全对等的，需要考虑如何处理多出来的位。

转换方向一：byte 转 int (自动类型提升 / 隐式转换)

这是最常见的一种转换,当一个小范围的类型（如 byte）被赋值给一个大范围的类型（如 int）时，Java 会自动进行。

关键点：符号扩展

byte 是有符号的，所以当它被提升为 int 时，不能简单地用 0 填充高 24 位，必须保持原始值的符号不变，这个过程就叫符号扩展。

• 如果原始 byte 是正数：它在内存中的最高位（符号位）是 0，转换为 int 时，高 24 位全部用 0 填充。
• 如果原始 byte 是负数：它在内存中的最高位（符号位）是 1，转换为 int 时，高 24 位全部用 1 填充。

示例

public class ByteToInt {
    public static void main(String[] args) {
        // 1. 正数转换
        byte b1 = 10; // 二进制: 00001010
        int i1 = b1;  // 自动提升
        // i1 的二进制: 00000000 00000000 00000000 00001010
        System.out.println("b1 = " + b1); // 输出: b1 = 10
        System.out.println("i1 = " + i1); // 输出: i1 = 10
        System.out.println("----------------------------");
        // 2. 负数转换
        byte b2 = -10; // 二进制: 11110110 (这是补码形式)
        int i2 = b2;   // 自动提升
        // i2 的二进制: 11111111 11111111 11111111 11110110
        // 高24位用1进行了填充，保持了负数符号
        System.out.println("b2 = " + b2); // 输出: b2 = -10
        System.out.println("i2 = " + i2); // 输出: i2 = -10
        System.out.println("----------------------------");
        // 3. 边界值转换
        byte b3 = Byte.MAX_VALUE; // 127
        int i3 = b3;
        System.out.println("b3 = " + b3); // 输出: b3 = 127
        System.out.println("i3 = " + i3); // 输出: i3 = 127
        byte b4 = Byte.MIN_VALUE; // -128
        int i4 = b4;
        System.out.println("b4 = " + b4); // 输出: b4 = -128
        System.out.println("i4 = " + i4); // 输出: i4 = -128
    }
}

byte 转 int 是自动、安全的，不会丢失数据，Java 编译器会自动处理符号扩展。

转换方向二：int 转 byte (强制类型转换 / 显式转换)

当大范围的类型（int）要赋值给小范围的类型（byte）时，Java 编译器会报错，因为这可能会导致数据丢失，你必须使用强制类型转换符 (byte) 来告诉编译器：“我知道这可能会丢失数据，请按我的方式执行。”

关键点：截断

强制转换的过程非常简单粗暴：直接丢弃 int 的高 24 位，只保留低 8 位，这个过程叫截断。

截断后的结果取决于原始 int 值的低 8 位：

• 如果低 8 位表示的是一个有效的 byte 值（即 -128 到 127），那么转换就是成功的。
• 如果低 8 位超出了 byte 的范围，那么结果会“回绕”，产生一个看似不正确但符合补码规则的值。

示例

public class IntToByte {
    public static void main(String[] args) {
        // 1. 在范围内的 int 转换
        int i1 = 100; // 二进制: 00000000 00000000 00000000 01100100
        byte b1 = (byte) i1; // 截断，只保留低8位: 01100100
        System.out.println("i1 = " + i1); // 输出: i1 = 100
        System.out.println("b1 = " + b1); // 输出: b1 = 100
        System.out.println("----------------------------");
        // 2. 超出正数范围的 int 转换 (回绕)
        int i2 = 300; // 二进制: 00000000 00000000 00000001 00101100
        byte b2 = (byte) i2; // 截断，只保留低8位: 00101100 (十进制是44)
        // 300的低8位是44，所以b2的值就是44
        System.out.println("i2 = " + i2); // 输出: i2 = 300
        System.out.println("b2 = " + b2); // 输出: b2 = 44  <-- 数据丢失了！
        System.out.println("----------------------------");
        // 3. 超出负数范围的 int 转换 (回绕)
        int i3 = -130; // 二进制: 11111111 11111111 11111111 01111110 (补码)
        byte b3 = (byte) i3; // 截断，只保留低8位: 01111110 (十进制是126)
        // -130的低8位是01111110，它被解释为一个正数
        System.out.println("i3 = " + i3); // 输出: i3 = -130
        System.out.println("b3 = " + b3); // 输出: b3 = 126 <-- 数据丢失了！
        System.out.println("----------------------------");
        // 4. 负数在范围内的情况
        int i4 = -50; // 二进制: 11111111 11111111 11111111 11001110 (补码)
        byte b4 = (byte) i4; // 截断，只保留低8位: 11001110 (补码，表示-50)
        System.out.println("i4 = " + i4); // 输出: i4 = -50
        System.out.println("b4 = " + b4); // 输出: b4 = -50
    }
}

int 转 byte 是不安全的，需要强制转换，并且会截断高位，导致数据丢失，开发者必须确保原始 int 值在 byte 的范围内，或者能接受截断后的结果。

实际应用场景

处理网络数据或文件流

当你从网络或文件中读取数据时,很多底层 API（如 InputStream.read()）返回的是 int 类型，但实际上它只读取了一个字节，你需要将其转换为 byte。

import java.io.FileInputStream;
import java.io.IOException;
public class StreamExample {
    public static void main(String[] args) throws IOException {
        try (FileInputStream fis = new FileInputStream("test.txt")) {
            // read() 方法返回一个 int，范围是 0-255，如果到达末尾返回 -1
            int dataAsInt = fis.read();
            if (dataAsInt != -1) {
                // 强制转换为 byte
                byte dataAsByte = (byte) dataAsInt;
                System.out.println("Read byte: " + dataAsByte);
            }
        }
    }
}

位操作与掩码

有时候你可能只想获取一个 int 值的最低 8 位，强制转换为 byte 是实现这一目的的直接方法。

public class BitMasking {
    public static void main(String[] args) {
        int flags = 0b11111111_11111111_11111111_10101010; // 一个很大的数
        // 方法1：强制转换
        byte lowestByte1 = (byte) flags;
        System.out.println("Method 1: " + lowestByte1); // 输出: -86 (因为10101010是负数)
        // 方法2：使用位掩码 (更清晰，推荐)
        byte lowestByte2 = (byte) (flags & 0xFF); // 0xFF 是 255，二进制 00000000 00000000 00000000 11111111
        // 与运算后，高24位必然为0，低8位保持不变
        // 然后强制转换，这次是安全的，因为值肯定在0-255之间
        System.out.println("Method 2: " + lowestByte2); // 输出: -86 (结果一样，但意图更明确)
    }
}

总结表格

核心要点回顾：

1. byte 到 int：自动完成，用符号填充高位，保证数值的准确性。
2. int 到 byte：必须强制转换，直接丢弃高位，可能导致数据丢失或回绕。
3. byte 是有符号的：在理解 byte 的行为时，一定要考虑它的符号位和补码表示法。
4. 实际编程：在处理 I/O 或底层操作时，这两种转换非常频繁，务必清楚它们的区别和风险。