核心概念：16进制字符串 vs 16进制数

• 16进制字符串："48656C6C6F"，它是一个 String 对象，由字符 '4', '8', '6', 'E', 'C', '6' 等组成，在内存中，每个字符都占用 2 个字节（使用 UTF-16 编码）。
• 16进制数：在 Java 中，这通常指的是 byte 类型，一个 byte 是 8 位，可以表示 0x00 到 0xFF 范围内的值。0x48 就是一个16进制数。

我们的目标就是将一个16进制字符串（如 "48656C6C6F"）转换成一个或多个 byte 值（如 [0x48, 0x65, 0x6C, 0x6C, 0x6F]）。

使用 java.lang.Integer 或 java.lang.Long（适用于单个16进制值）

如果你的字符串只代表一个16进制数，"FF" 或 "1A3F"，你可以使用 Integer 或 Long 的 parseInt 方法。

示例代码

public class HexStringToSingleHex {
    public static void main(String[] args) {
        // 1. 定义一个16进制字符串
        String hexString = "FF"; // 代表 255
        // 2. 使用 Integer.parseInt 进行转换
        // parseInt 的第二个参数 16 表示源字符串是 16 进制
        int intValue = Integer.parseInt(hexString, 16);
        System.out.println("16进制字符串 '" + hexString + "' 转换为 int: " + intValue); // 输出: 255
        // 如果数值可能超过 int 的范围，可以使用 Long
        String longHexString = "FFFFFFFFFFFFFFFF"; // 代表 2^64 - 1
        long longValue = Long.parseLong(longHexSring, 16);
        System.out.println("16进制字符串 '" + longHexString + "' 转换为 long: " + longValue);
        // 3. 将 int/long 转换为 byte (只取低8位)
        byte byteValue = (byte) intValue; // (byte) 255 结果是 -1 (因为 byte 是有符号的)
        System.out.println("int " + intValue + " 转换为 byte: " + byteValue); // 输出: -1
        // 如果希望得到无符号的 byte 值 (0-255)，可以使用 & 0xFF
        int unsignedByteValue = intValue & 0xFF;
        System.out.println("int " + intValue + " 转换为无符号 byte: " + unsignedByteValue); // 输出: 255
    }
}

适用场景：当字符串只包含一个16进制数字时。

使用 javax.xml.bind.DatatypeConverter（经典方法，已过时）

在 Java 8 之前，这是将16进制字符串和字节数组互转最方便、最常用的方法，它在 javax.xml.bind 包中。

注意：javax.xml.bind 模块在 Java 9 中被标记为过时，在 Java 11 中被移除，如果你的项目使用 Java 8+,请优先考虑下面的方法。

示例代码

import javax.xml.bind.DatatypeConverter;
public class HexStringToBytesLegacy {
    public static void main(String[] args) {
        String hexString = "48656C6C6F20576F726C64"; // "Hello World"
        // 将16进制字符串转换为字节数组
        byte[] byteArray = DatatypeConverter.parseHexBinary(hexString);
        // 打印字节数组内容
        System.out.println("转换后的字节数组: " + java.util.Arrays.toString(byteArray));
        // 输出: [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
        // 将字节数组转换回16进制字符串
        String convertedBack = DatatypeConverter.printHexBinary(byteArray);
        System.out.println("转换回的16进制字符串: " + convertedBack);
        // 输出: 48656C6C6F20576F726C64
    }
}

适用场景：遗留项目或仍在使用 Java 8 的项目,新项目不推荐。

使用 java.base 包中的 HexFormat（推荐，Java 17+）

这是 Java 17 引入的新特性，是处理16进制格式的现代、标准化的方式，它比 DatatypeConverter 更灵活，并且属于核心 java.base 模块,无需任何额外依赖。

示例代码

import java.util.HexFormat;
public class HexStringToBytesModern {
    public static void main(String[] args) {
        String hexString = "48656C6C6F20576F726C64"; // "Hello World"
        // 1. 创建 HexFormat 实例 (使用默认设置)
        HexFormat hexFormat = HexFormat.of();
        // 2. 将16进制字符串转换为字节数组
        byte[] byteArray = hexFormat.parseHex(hexString);
        // 打印字节数组内容
        System.out.println("转换后的字节数组: " + java.util.Arrays.toString(byteArray));
        // 输出: [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
        // 3. 将字节数组转换回16进制字符串 (默认小写)
        String convertedBackLower = hexFormat.formatHex(byteArray);
        System.out.println("转换回的16进制字符串 (小写): " + convertedBackLower);
        // 输出: 48656c6c6f20576f726c64
        // 4. 可以配置 HexFormat 以生成大写字符串
        HexFormat hexFormatUpper = HexFormat.of().withUpperCase();
        String convertedBackUpper = hexFormatUpper.formatHex(byteArray);
        System.out.println("转换回的16进制字符串 (大写): " + convertedBackUpper);
        // 输出: 48656C6C6F20576F726C64
    }
}

适用场景：所有新项目，特别是使用 Java 17 或更高版本 的项目,这是目前最推荐的方法。

手动实现（不推荐，但有助于理解原理）

如果你不能使用 Java 17+ 的 HexFormat，也不想引入外部库，可以自己写一个转换方法，这种方法容易出错,不推荐在生产环境中使用。

示例代码

import java.util.Arrays;
public class HexStringToBytesManual {
    public static void main(String[] args) {
        String hexString = "48656C6C6F";
        byte[] byteArray = hexStringToByteArray(hexString);
        System.out.println("手动转换后的字节数组: " + Arrays.toString(byteArray));
        // 输出: [72, 101, 108, 108, 111]
    }
    public static byte[] hexStringToByteArray(String s) {
        int len = s.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            // 检查字符串长度是否为偶数
            if (i + 1 > len) {
                throw new IllegalArgumentException("Hex string must have an even length");
            }
            // 从字符串中提取两个字符
            String byteChar = s.substring(i, i + 2);
            // 将这两个字符解析为 byte
            data[i / 2] = (byte) Integer.parseInt(byteChar, 16);
        }
        return data;
    }
}

适用场景：学习或在没有现代 Java 版本且不能使用第三方库的极端情况下。

总结与推荐

最终建议：

1. 如果你的项目使用 Java 17 或更高版本，请毫不犹豫地使用 HexFormat，这是最标准、最安全、最现代的选择。
2. 如果你的项目使用 Java 8 到 Java 16，并且不想引入第三方库，你可以手动实现一个转换方法（如方法四），或者使用 DatatypeConverter（但需要知道它已过时）。
3. 如果你的字符串只代表一个单独的16进制数（如 "A5"），使用 Integer.parseInt(s, 16) 是最简单直接的方法。