核心要点

1. 不要使用 String.valueOf(byte b)：这个方法会将 byte 解释为其ASCII 码值对应的字符。byte b = 65 会被转换成字符串 "A"，这通常不是我们想要的结果，尤其是在处理数字时。
2. 明确你的意图：你是想把 byte 当作一个数字来表示，还是当作二进制数据的一部分来处理？这是选择正确方法的关键。

将 byte 转换为其十进制数字的字符串表示

这是最常见的需求,byte b = 123，你想得到字符串 "123"。

方法1：使用 String.valueOf() 的重载方法（推荐）

String 类有一个专门接受 int 参数的 valueOf() 方法，Java 会自动将 byte 提升为 int，然后转换成字符串。

public class ByteToStringExample {
    public static void main(String[] args) {
        byte number = 123;
        byte negativeNumber = -45;
        // 推荐：将 byte 视为数字并转换为 String
        String str1 = String.valueOf(number);
        String str2 = String.valueOf(negativeNumber);
        System.out.println("Byte " + number + " as String: " + str1); // 输出: Byte 123 as String: 123
        System.out.println("Byte " + negativeNumber + " as String: " + str2); // 输出: Byte -45 as String: -45
    }
}

方法2：使用 Integer.toString()

你也可以先将 byte 转换为 int，然后使用 Integer.toString()，效果与第一种方法相同。

byte number = 123;
String str = Integer.toString(number);
System.out.println(str); // 输出: 123

⚠️ 错误示范（常见陷阱）

byte b = 65;
// 错误：这会得到字符 'A' 的字符串，而不是数字 "65"
String wrongStr = String.valueOf(b); 
System.out.println(wrongStr); // 输出: A

将 byte 转换为十六进制（Hex）字符串

这在处理网络数据、哈希值（如 MD5, SHA）、文件字节流等场景中非常普遍。byte b = 15 想要得到字符串 "0F"。

方法1：使用 String.format()（简洁易读）

这是最简单、最直观的方法。

public class ByteToHexExample {
    public static void main(String[] args) {
        byte b = 15;
        byte b2 = -128; // 测试负数
        // %02x 的含义：
        // % : 格式化开始
        // 0 : 用零填充
        // 2 : 总共2位宽度
        // x : 十六进制小写字母表示
        String hexStr = String.format("%02X", b); // 使用 %02X 可以得到大写
        String hexStr2 = String.format("%02x", b2);
        System.out.println("Byte " + b + " as Hex String: " + hexStr); // 输出: Byte 15 as Hex String: 0F
        System.out.println("Byte " + b2 + " as Hex String: " + hexStr2); // 输出: Byte -128 as Hex String: 80
    }
}

方法2：手动计算（更底层，有助于理解原理）

如果你想了解背后的原理,可以自己实现转换逻辑。

public class ByteToHexManual {
    public static void main(String[] args) {
        byte b = 15;
        // 在 Java 中，byte 是有符号的，为了处理所有位（包括符号位），需要先转换为 int
        int unsignedInt = b & 0xFF; // 0xFF 是 255，这个操作会去掉符号位扩展，只保留低8位
        // 将高4位和低4位分别转换为十六进制字符
        char highChar = Character.forDigit((unsignedInt >> 4) & 0xF, 16);
        char lowChar = Character.forDigit(unsignedInt & 0xF, 16);
        String hexStr = new String(new char[]{highChar, lowChar});
        System.out.println(hexStr.toUpperCase()); // 输出: 0F
    }
}

将字节数组（byte[]）转换为字符串

通常我们处理的是 byte 数组，而不是单个 byte，这里的关键是字符编码，否则会出现乱码。

方法1：使用 new String(byte[] bytes, charset)（最规范、最安全）

这是处理字节数组到字符串转换的标准方法，你必须指定字符编码，如 StandardCharsets.UTF_8。

import java.nio.charset.StandardCharsets;
public class BytesToStringExample {
    public static void main(String[] args) {
        String originalString = "你好，世界！Hello World!";
        byte[] utf8Bytes = originalString.getBytes(StandardCharsets.UTF_8);
        // 使用相同的编码将字节数组转换回字符串
        String decodedString = new String(utf8Bytes, StandardCharsets.UTF_8);
        System.out.println("Original String: " + originalString);
        System.out.println("Decoded String:  " + decodedString);
        System.out.println("Are they equal?  " + originalString.equals(decodedString)); // true
    }
}

⚠️ 错误示范（常见陷阱）

如果不指定编码,Java 会使用平台的默认字符集（如 Windows 可能是 GBK，Linux/macOS 可能是 UTF-8），这极易导致乱码。

// 假设系统默认编码是 GBK，但字节流是 UTF-8 编码的
byte[] utf8Bytes = "你好".getBytes(StandardCharsets.UTF_8); 
// 错误：使用系统默认编码（可能是GBK）去解码UTF-8字节，会产生乱码
String wrongString = new String(utf8Bytes); 
System.out.println(wrongString); // 可能输出乱码，如 "浣犲ソ"

总结与最佳实践

核心原则：

1. 处理单个数字：用 String.valueOf()。
2. 处理单个字节的十六进制表示：用 String.format()。
3. 处理字节数组（文本）：永远、永远、永远要指定字符编码，优先使用 StandardCharsets.UTF_8。