为什么不能直接转换？

1. 数据大小不同：

   
   （图片来源网络，侵删）
   • char: 2 个字节 (16 位)，它使用 Unicode 字符集（UTF-16 编码）来表示一个字符，字符 'A' 的 Unicode 码点是 U+0041，在内存中占用两个字节。
   • byte: 1 个字节 (8 位)，它是一个有符号的整数，范围是 -128 到 127。

2. Java 的类型转换规则：

   • Java 是一种强类型语言，当将一种数据类型转换为另一种数据类型时，必须有明确的转换指令。
   • 从一个范围更宽的类型（如 char, 16位）转换到一个范围更窄的类型（如 byte, 8位），需要进行显式类型转换（casting），否则，编译器会报错。

转换方式

char 转 byte 主要有以下几种方式，具体取决于你的需求：

强制类型转换 (Casting)

这是最直接的方式,它只取 char 值的低 8 位（即最低有效字节，Lower Byte）。

工作原理： 一个 char 值由两个字节组成（高字节和低字节），强制转换为 byte 会丢弃高字节，只保留低字节的值。

示例代码：

public class CharToByteExample {
    public static void main(String[] args) {
        // 情况 1: 字符 'A' 的 Unicode 是 U+0041
        // 二进制表示: 00000000 01000001
        // 低 8 位 (低字节): 01000001
        // 01000001 的十进制值是 65
        char charA = 'A';
        byte byteA = (byte) charA;
        System.out.println("字符 '" + charA + "' 转换为 byte: " + byteA); // 输出: 65
        System.out.println("--------------------");
        // 情况 2: 字符 '你' 的 Unicode 是 U+4F60
        // 二进制表示: 01001111 01100000
        // 低 8 位 (低字节): 01100000
        // 01100000 的十进制值是 96
        char charYou = '你';
        byte byteYou = (byte) charYou;
        System.out.println("字符 '" + charYou + "' 转换为 byte: " + byteYou); // 输出: 96
        System.out.println("--------------------");
        // 情况 3: 一个字符，其低 8 位超出了 byte 的正数范围
        // 假设一个字符的 Unicode 是 U+00FF (等同于 (char) 255)
        // 二进制表示: 00000000 11111111
        // 低 8 位 (低字节): 11111111
        // 在 Java 中，byte 是有符号的，11111111 的补码表示 -1
        char char255 = (char) 0x00FF;
        byte byte255 = (byte) char255;
        System.out.println("字符 '\\u00FF' 转换为 byte: " + byte255); // 输出: -1
        System.out.println("--------------------");
        // 情况 4: 一个字符，其低 8 位超出了 byte 的负数范围
        // 假设一个字符的 Unicode 是 U+01FF
        // 二进制表示: 00000001 11111111
        // 低 8 位 (低字节): 11111111 (同样是 -1)
        char char511 = (char) 0x01FF;
        byte byte511 = (byte) char511;
        System.out.println("字符 '\\u01FF' 转换为 byte: " + byte511); // 输出: -1
    }
}

适用场景： 当你只关心字符编码的低字节部分时使用，这在处理某些二进制协议、文件格式或网络数据包时很常见。

转换为字符的 ASCII/ISO-8859-1 编码值

这种方式将字符视为一个 ISO-8859-1 (Latin-1) 字符，然后获取其对应的字节值，对于 ASCII 字符（0-127）和许多欧洲字符，这与 char 的低字节值相同。

工作原理： 使用 String.getBytes(charset) 方法。Charset.forName("ISO-8859-1") 是一个“8-bit clean”的编码，它直接将字符的码点映射到一个字节上，不会进行任何转换，只要码点在 0-255 范围内。

示例代码：

import java.nio.charset.Charset;
public class CharToByteEncodingExample {
    public static void main(String[] args) {
        char charA = 'A';
        // 将字符包装成字符串，然后使用指定编码获取字节数组
        byte[] bytesA = String.valueOf(charA).getBytes(Charset.forName("ISO-8859-1"));
        // 因为只有一个字符，所以取第一个字节
        byte byteA_encoded = bytesA[0];
        System.out.println("字符 '" + charA + "' 通过 ISO-8859-1 编码为 byte: " + byteA_encoded); // 输出: 65
        System.out.println("--------------------");
        char charYou = '你';
        // '你' 的 Unicode 码点是 20320 (0x4F60)，超出了 ISO-8859-1 的范围 (0-255)
        // 这种情况下，行为是未定义的或者会抛出异常，具体取决于 JVM 实现。
        // 更安全的做法是检查字符是否在编码范围内。
        if (charYou <= 255) {
            byte[] bytesYou = String.valueOf(charYou).getBytes(Charset.forName("ISO-8859-1"));
            byte byteYou_encoded = bytesYou[0];
            System.out.println("字符 '" + charYou + "' 通过 ISO-8859-1 编码为 byte: " + byteYou_encoded);
        } else {
            System.out.println("字符 '" + charYou + "' 的码点超出了 ISO-8859-1 编码范围，无法直接转换。");
        }
    }
}

适用场景： 当你需要确保字符被解释为单字节编码（如 Latin-1）时，这在处理遗留系统或需要严格 8 位数据的场景中非常有用。

转换为字符的 UTF-8 编码值

这是处理任意 Unicode 字符最标准、最推荐的方式，UTF-8 是一种可变长度的编码，ASCII 字符用 1 个字节表示，非 ASCII 字符用 2、3 或 4 个字节表示。

工作原理： 同样使用 String.getBytes(charset)，但这次使用 StandardCharsets.UTF_8。

示例代码：

import java.nio.charset.StandardCharsets;
public class CharToByteUTF8Example {
    public static void main(String[] args) {
        char charA = 'A'; // ASCII 字符
        byte[] bytesA_utf8 = String.valueOf(charA).getBytes(StandardCharsets.UTF_8);
        System.out.println("字符 '" + charA + "' 的 UTF-8 编码: " + java.util.Arrays.toString(bytesA_utf8)); // 输出: [65]
        System.out.println("UTF-8 编码的字节数: " + bytesA_utf8.length); // 输出: 1
        System.out.println("--------------------");
        char charYou = '你'; // 中文字符
        byte[] bytesYou_utf8 = String.valueOf(charYou).getBytes(StandardCharsets.UTF_8);
        System.out.println("字符 '" + charYou + "' 的 UTF-8 编码: " + java.util.Arrays.toString(bytesYou_utf8)); // 输出: [-28, -72, -96]
        System.out.println("UTF-8 编码的字节数: " + bytesYou_utf8.length); // 输出: 3
        System.out.println("--------------------");
        // 如果目标是得到单个 byte，你需要明确要取哪个
        // 取第一个字节
        if (bytesYou_utf8.length > 0) {
            byte firstByteOfYou = bytesYou_utf8[0];
            System.out.println("字符 '" + charYou + "' 的 UTF-8 编码的第一个字节: " + firstByteOfYou); // 输出: -28
        }
    }
}

适用场景： 这是在现代应用程序、网络通信（如 HTTP）、文件存储中处理文本数据的标准方式，它能正确处理所有 Unicode 字符，而不仅仅是低字节或特定编码范围内的字符。

总结与建议

核心建议：

• 如果你只需要一个字节，并且明确知道你要丢弃高字节，使用强制转换 (byte) myChar。
• 如果你在处理文本，并且需要确保数据能被正确地序列化和反序列化，永远优先使用 UTF-8 编码，这是最健壮、最标准的方法。
• 仅在特殊情况下（如处理某些老旧的二进制格式），才考虑使用 ISO-8859-1 的方式。