Skip to content

16进制转字符串 · 字符串转16进制

16进制转字符串、字符串转16进制在线互转:中文自动识别 GBK/UTF-8 不乱码,xxd/hexdump 输出、Java byte[]、0x 和 \x 格式直接粘贴就能转。支持 ASCII、UTF-16,可输出 C/Java/Python 数组。浏览器本地转换,不上传。

无追踪 浏览器中运行 免费
转换全部在浏览器本地完成,粘贴的内容不会离开你的设备。
试试示例

按普通16进制读取 · 13 字节

    字符串
    Hello, 世界

    自动识别为 UTF-8:所有多字节序列都合法。

    同一串字节在各编码下的读法

    编码 读作
    UTF-8 可完整解码 Hello, 世界
    GBK / GB18030 可完整解码 Hello, 涓栫晫
    UTF-16LE 有无法解码的字节 效汬Ɐ隸闧�
    UTF-16BE 有无法解码的字节 䡥汬漬⃤뢖�
    ISO-8859-1 可完整解码 Hello, ä¸<96>ç<95><8C>
    文中引用的 hexdump、字节数组和报错信息来自 xxd、Python 3.14、Node.js 26、Go 1.27 和 clang 的实际运行结果;引擎的每种输出格式都有测试确保能读回原字节。Java 与 PHP 的行为引自官方文档。 — Go Tools 工程团队 · 2026年9月16日

    由开发 Go Tools 编码类工具的工程师撰写并审核。页面引用的每个16进制值和转换结果都由页面自身的引擎算出,并由自动化测试逐项核对。

    16进制转ASCII速查

    48 65 6C 6C 6F 转字符串是什么?

    Hello 按 ASCII 和 UTF-8,48 是 H,65 是 e,6C 是 l,6F 是 o。

    一个汉字几个字节?

    UTF-8 通常 3 个,GBK 2 个 「你」在 UTF-8 里是 E4 BD A0,在 GBK 里是 C4 E3。

    0D 0A 是什么?

    CR LF(\r\n) 回车加换行,Windows、HTTP 和大多数串口指令集使用的换行方式。

    字母 A 的16进制是多少?

    41 小写 a 是 61,大小写字母的16进制始终相差 20。

    什么是16进制转字符串?

    16进制是书写字节的一种方式:每个字节(0 到 255)写成 00FF 的两位数字。16进制转字符串,就是把这些字节还原成可读的文字,而这一步永远绕不开 字符编码——规定哪个字节、或哪几个字节代表哪个字符的那张表。

    英文内容里通常感觉不到编码的存在,因为 ASCII、UTF-8、GBK 等绝大多数编码对 007F 的规定是一致的。换成其他字符就立刻不同了:C4 E3 BA C3 按 GBK 是「你好」,按 UTF-8 是非法字节;而「你好」的 UTF-8 编码是 E4 BD A0 E5 A5 BD。16进制只是一半信息,编码是另一半。

    字符串转16进制则反过来:先把文字按编码变成字节,再把每个字节写成两位16进制。开发者用它查看串口或数据库字段里到底存了什么、把二进制数据写进源代码,以及对比两个系统实际收发的字节。

    $ echo 48656c6c6f | xxd -r -p
    Hello
    
    >>> bytes.fromhex('c4e3bac3').decode('gbk')
    '你好'
    >>> bytes.fromhex('c4e3bac3').decode('utf-8')
    UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc4 in position 0: invalid continuation byte

    这个16进制转换工具能做什么

    什么格式的16进制都能粘

    空格、冒号、横线分隔或紧凑写法,0x 值、\x 转义、% 编码,C、Go、Java 数组,Java Arrays.toString 的有符号输出,Python bytes 字面量,Node.js Buffer,以及 xxd、hexdump -C、od 的整屏输出。页面会告诉你识别成了什么、去掉了什么。

    中文自动识别 GBK/UTF-8,并说明理由

    自动识别依次检查 BOM、合法的 UTF-8、UTF-16、纯 ASCII,最后是 GBK,并写明是哪条规则做出的判断。只有按 GBK 读全是常用汉字时才判为 GBK,所以串口里的短二进制帧会提示「很可能不是文本」,而不是显示成一串乱七八糟的中文。

    所有编码的读法并排对照

    同一串字节分别按 UTF-8、GBK、UTF-16LE、UTF-16BE、ISO-8859-1 显示,并标明能否完整解码。转出乱码时,正确的读法通常就在下一行。

    看得见不可见字符

    NUL、CR、LF、ESC 等控制字节显示为 ␀ ␍ ␊ ␛,协议数据末尾多出的 00 或缺少的 0D 一眼可见。复制时仍然是原始字符。

    输出直接粘进代码

    字符串转16进制可输出空格分隔或紧凑的16进制、0x 列表、\x 转义、xxd -i 风格的 C 数组、带符号值的 Java byte[]、与 repr() 一致的 Python bytes、Go []byte 或 xxd 格式——这些格式本页也都能读回原字节。

    数据不离开浏览器

    解析与解码都在本地用 JavaScript 完成,不上传、不保存、不写进网址,抓包数据和生产日志可以放心粘贴。

    各语言16进制与字符串互转写法

    Python 3

    bytes.fromhex(h).decode()

    bytes.fromhex('48 65 6c 6c 6f').decode('utf-8') 返回 'Hello';字节之间可以有空格,不能带 0x 前缀。反方向是 s.encode('utf-8').hex(),空格分隔用 .hex(' ')。中文是 GBK 时编解码都传 'gbk'

    JavaScript(Node.js)

    Buffer.from(h, 'hex')

    Buffer.from(h, 'hex').toString('utf8') 解码,Buffer.from(s, 'utf8').toString('hex') 编码。非法输入不会报错:解码在第一个非法两位组处停止,末尾多出的一位被丢弃,所以要先校验。

    JavaScript(浏览器)

    TextDecoder / TextEncoder

    parseInt(pair, 16) 逐组解析成 Uint8Array,再 new TextDecoder('utf-8').decode(bytes)TextDecoder 还能读 'gbk''big5''shift_jis',但 TextEncoder 只能输出 UTF-8。

    Java 17+

    HexFormat.of()

    new String(HexFormat.of().parseHex(h), StandardCharsets.UTF_8) 解码,HexFormat.of().formatHex(s.getBytes(StandardCharsets.UTF_8)) 编码。旧版本逐字节 String.format("%02x", b);不要用 Integer.toHexString(b),负字节会打印成 ffffffe4

    Go

    encoding/hex

    hex.DecodeString(h) 返回字节,string(b) 转成字符串;hex.EncodeToString([]byte(s)) 反过来。它很严格:有空格返回 invalid byte: U+0020 ' ',奇数长度返回 odd length hex string

    C 语言

    sscanf%2hhx

    每次两位读进 unsigned char 缓冲区,末尾补 '\0'。打印16进制时先转成 unsigned char 再用 %02X,否则在 char 有符号的平台上,大于 0x7F 的字节会打印成 FFFFFFE4

    PHP

    hex2bin() / bin2hex()

    hex2bin('48656c6c6f') 返回 Hellobin2hex('Hello') 返回 48656c6c6f。手册说明:长度为奇数或不是合法16进制时,hex2bin() 返回 false 并产生 E_WARNING

    Shell(xxd)

    xxd -r -p / xxd -p

    echo 48656c6c6f | xxd -r -p 输出 Hello,printf 'Hello' | xxd -p 输出 48656c6c6f。编码时用 printf 而不是 echo,因为 echo 会在末尾多加一个换行 0a

    C#(.NET 5+)

    Convert.FromHexString()

    Encoding.UTF8.GetString(Convert.FromHexString(h)) 解码,Convert.ToHexString(Encoding.UTF8.GetBytes(s)) 编码(输出大写、无分隔符)。FromHexString 不接受空格和 0x 前缀。.NET Core 与 .NET 5+ 默认不带 GBK,要先 Encoding.RegisterProvider(CodePagesEncodingProvider.Instance),再 Encoding.GetEncoding(936)

    Hex转字符串示例:UTF-8、GBK、xxd、Java byte[]

    UTF-8 编码的中英文 16进制转字符串

    48 65 6C 6C 6F 2C 20 E4 B8 96 E7 95 8C
    Hello, 世界

    前 7 个字节是普通 ASCII:48 65 6C 6C 6F 是 Hello,2C 是逗号,20 是空格。E4 B8 96E7 95 8C 是「世」「界」的 UTF-8 三字节序列——常用汉字在 UTF-8 里都占 3 个字节。所有序列都合法,所以自动识别为 UTF-8。

    GBK 编码的传感器读数:按 UTF-8 转就是乱码

    CE C2 B6 C8 3A 32 35 2E 33 A1 E6
    温度:25.3℃

    很多串口设备发送的中文是 GBK。这里 CE C2 是「温」,B6 C8 是「度」,3A 32 35 2E 33 是 ASCII 的 :25.3A1 E6 是全角符号 ℃——每个汉字或全角符号占 2 个字节。按 UTF-8 读这串字节不合法(CE 表示双字节序列的开头,紧跟着的 C2 却不是续字节),按 GBK 读则全是常用字,所以自动识别选 GBK。只会按 UTF-8 转的工具,在这里只能输出一串替换符。

    直接粘贴 xxd 的输出

    00000000: 4869 20e4 bda0 e5a5 bd0d 0a              Hi ........
    Hi 你好␍␊

    这就是 printf 'Hi 你好\r\n' | xxd 的原样输出。转换前会先去掉偏移列 00000000: 和右侧字符栏;如果把偏移当成数据,光这 8 个 0 就会在开头多出 4 个 NUL 字节。最后两个字节 0d 0a 是 Windows 换行,显示为 ␍␊。

    日志里的 Java byte 数组

    [-28, -72, -83, -26, -106, -121]
    中文

    Arrays.toString(bytes) 按十进制打印 Java 的有符号字节。负数就是 0x80 及以上的字节:-28 即 256 − 28 = 228 = 0xE4。这 6 个字节 E4 B8 AD E6 96 87 是「中文」的 UTF-8 编码。

    字符串转16进制:串口 AT 指令

    AT+CSQ\r\n
    41 54 2B 43 53 51 0D 0A

    模块和大多数串口指令集要求每条指令以回车加换行结尾。文本框里按回车只会产生 0A,所以要勾选 换行按 CR LF,结尾才会变成 0D 0A

    被转了两次的16进制

    653462646130653561356264
    e4bda0e5a5bd → 你好

    这里每个字节都是 ASCII 的16进制字符(65 是 e,34 是 4,62 是 b),所以第一次转出来的还是一串16进制。原因通常是16进制字符串被当成普通文本又转了一次。本页会提供再解一层,得到「你好」。为了避免误报,只有第一层结果至少 12 位16进制、第二层又能解成正常文本时才提示——日期、时间戳、CRC32 值和 MD5 都不会触发。

    16进制转字符串、字符串转16进制怎么用

    1. 1

      粘贴16进制

      在「16进制 → 字符串」页签粘贴,手上是什么格式就粘什么:带空格的、紧凑的、0x、\x 转义、字节数组,或者 xxd 的整屏输出。输入框下方会写明按什么格式读取。

    2. 2

      核对字符串和编码

      右侧显示转换结果、自动识别出的编码和理由。如果识别错了,下方表格列出了所有编码的读法,在「编码」菜单里选正确的那个。

    3. 3

      留意不可见字符

      NUL、CR、LF 等控制字节显示为 ␀ ␍ ␊。取消勾选「显示不可见字符」可以看原文,然后复制结果。

    4. 4

      或者字符串转16进制

      在「字符串 → 16进制」页签选择编码和输出格式——空格分隔、0x、C/Java/Python/Go 数组,或 xxd 格式。发给串口和网络协议时勾选 CR LF。

    16进制转字符串乱码、出错的常见原因

    把 GBK 字节按 UTF-8 解码

    老 Windows 软件、很多串口设备和旧数据库里的中文是 GBK。按 UTF-8 解码要么报错,要么满屏替换符。看编码对照表,用读得通的那一种。

    ✗ 错误
    >>> bytes.fromhex('c4e3bac3').decode('utf-8')
    UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc4 in position 0: invalid continuation byte
    ✓ 正确
    >>> bytes.fromhex('c4e3bac3').decode('gbk')
    '你好'

    JavaScript 用 charCodeAt() 取字节

    charCodeAt() 返回的是 UTF-16 码元。ASCII 字符恰好与字节相同,所以问题只在其他字符上暴露,得到的值不是任何 UTF-8 系统实际发送的字节。

    ✗ 错误
    '你'.charCodeAt(0).toString(16)   // '4f60':UTF-16 码元
    ✓ 正确
    Buffer.from('你', 'utf8').toString('hex')   // 'e4bda0':UTF-8 字节

    Java 用 Integer.toHexString 格式化有符号字节

    Java 的 byte 有符号,0x80 及以上的字节是负数。Integer.toHexString() 按 int 处理,负数会打印成 32 位无符号16进制,而且去掉前导零。

    ✗ 错误
    Integer.toHexString(b)        // 0xE4 得到 "ffffffe4",0x0A 得到 "a"
    ✓ 正确
    String.format("%02x", b)      // "e4"、"0a"

    直接相信 Node.js Buffer.from() 的结果

    Buffer.from(hex, 'hex') 从不抛错:遇到第一个非法的两位组就停下,末尾多出的一位直接忽略。打错一个字符,得到的是一个变短的 Buffer,而不是报错。

    ✗ 错误
    Buffer.from('486', 'hex')      // <Buffer 48>:6 被悄悄丢掉
    Buffer.from('48zz65', 'hex')   // <Buffer 48>:在 zz 处停下
    ✓ 正确
    if (!/^([0-9a-f]{2})*$/i.test(hex)) throw new Error('invalid hex');
    Buffer.from(hex, 'hex');

    hexdump 连同偏移列一起粘贴

    只会去空格的转换器会把偏移 00000000: 当成数据,把右侧字符栏里像16进制的部分也读进去。结果开头是几个 NUL 字节,后面全部错位。要么用 xxd -p 输出纯16进制,要么直接粘到本页,偏移列和字符栏会被识别出来。

    ✗ 错误
    00000000: 4869 20e4 bda0 e5a5 bd0d 0a              Hi ........
    → 直接去空格读:00 00 00 00 48 69 20 e4 …
    ✓ 正确
    $ printf 'Hi 你好\r\n' | xxd -p
    486920e4bda0e5a5bd0d0a

    设备要 CR LF,却只发了 LF

    AT 指令模块和很多按行解析的协议,要求每条指令以回车加换行结尾。只以 0A 结尾的指令常常被直接忽略,而且没有任何错误提示。

    ✗ 错误
    41 54 2B 43 53 51 0A      AT+CSQ 后面只有 LF
    ✓ 正确
    41 54 2B 43 53 51 0D 0A   AT+CSQ 后面是 CR LF

    什么时候需要16进制转字符串

    串口、UART 调试
    串口调试助手常以16进制显示收到的数据。粘贴一帧就能读出其中的文字,看清结尾的 0D 0A00;反过来还能把指令转成16进制,按设备要求加上 CR LF。
    查看抓包数据
    从 Wireshark、tcpdump 复制出来的协议载荷是16进制。解出帧里的请求行、JSON 或设备名,比临时写脚本快,而且数据不出本机。
    日志里的字节数组
    Java 按有符号十进制打印字节数组,Python 打印成 b'...',Node.js 打印成 <Buffer ...>。把日志片段原样粘进来就能看到文字,包括它是 UTF-8 还是 GBK。
    数据库里的16进制字段和 BLOB
    数据库客户端把二进制字段显示为16进制。解码一个值确认实际存了什么,或把字符串转成16进制,与库里的内容逐字节比对。
    固件和 C 源码里的字符串
    嵌入式代码常把文字存成字节数组。把字符串转成可以直接粘贴的 C 数组,或把头文件里的数组转回文字,确认设备会显示什么。

    16进制与字符串的对应原理:ASCII、UTF-8、GBK、UTF-16

    每个字节两位16进制
    一个字节 8 位,一位16进制 4 位,所以每个字节恰好是两位16进制 00FF,字节数永远是16进制位数的一半。大小写含义相同。分隔符、前缀和数组语法都只是写法:486548 650x48, 0x65\x48\x65 是同样的两个字节。
    ASCII:所有编码都认同的那部分
    ASCII 规定了 007F。可打印字符从 20(空格)到 7E(~),其余是控制字符,实际数据里最常见的是 00(NUL)、09(制表符)、0A(换行)、0D(回车)和 1B(ESC)。UTF-8、GBK、ISO-8859-1 都保留了这些值,所以纯英文用错编码通常也不会乱码。
    UTF-8:每个字符 1 到 4 个字节
    UTF-8 把 ASCII 写成单字节,其他字符写成多字节序列。首字节决定长度——C2DF 两字节,E0EF 三字节,F0F4 四字节——后续每个字节都必须落在 80BF。结构如此严格,GBK 编码的中文句子几乎不可能恰好是合法 UTF-8——我们用 33,910 句中文实测,只有 55 句是——这也是自动识别信任「UTF-8 解码成功」的原因。单个汉字则不同:约 18% 的 GBK 汉字恰好能组成合法的 UTF-8 双字节序列。
    GBK:每个汉字 2 个字节
    GBK 中 ASCII 仍是单字节,汉字和全角标点是双字节:首字节 81FE,尾字节 40FE(不含 7F)。尾字节范围很宽,较短的 UTF-8 文本按 GBK 读经常不报任何错,只是变成一串无关的字——E4 BD A0 E5 A5 BD(你好)会读成「浣犲ソ」——所以本页先试 UTF-8。GB18030 在 GBK 基础上增加了四字节序列表示生僻字,解码时同样支持。
    UTF-16 与字节序
    UTF-16 每个字符 2 个字节(基本平面之外 4 个),两个字节的先后顺序有两种。UTF-16LE 低字节在前——A 是 41 00;UTF-16BE 高字节在前——00 41。Windows API 和很多文件用小端,并可能以字节序标记 FF FE 开头;UTF-8 文件有时以 EF BB BF 开头。自动识别会去掉 BOM 并给出提示。

    16进制与字符串互转的正确做法

    两端都写明编码
    16进制本身不说明用的是什么编码。凡是把文字变成字节的地方——getBytes()encode()、串口助手的设置、数据库连接字符集——都显式指定编码,并在16进制旁边注明,别让另一端去猜。
    操作字节,而不是字符码
    返回字符码的函数,比如 JavaScript 的 charCodeAt()、Java 的 char 值,给出的是 UTF-16 码元而不是编码后的字节。先用 TextEncoderBuffer.from()getBytes(StandardCharsets.UTF_8) 编码,再格式化字节。
    每个字节都补足两位
    %02x 或等价写法,不要直接调用数字转16进制。日志里 a0a 看着差不多,可把没补零的值拼起来,会得到奇数长度,甚至解出完全不同的字节。
    同一份日志用同一种分隔格式
    日志和调试输出选定一种格式(例如空格分隔的两位组)并坚持使用。混用格式人眼容易读懂,脚本却容易读错,尤其是有的补了零、有的没补。
    核对字节数
    相信转换结果之前,先把字节数和预期对一下:协议头里的长度字段、数据库字段长度或文件大小。本页两个方向都会显示字节数。

    16进制转字符串常见问题

    16进制怎么转字符串?
    把16进制粘到本页「16进制 → 字符串」的输入框里,字符串会立即显示出来。手动转分两步。第一步,两位一组拆开:每两个16进制数字是一个字节,范围 00FF,所以 48656c6c6f 是 48、65、6C、6C、6F 五个字节。第二步,按某种字符编码把字节解码成字符。在 ASCII 和 UTF-8 里,48 是 H、65 是 e、6C 是 l、6F 是 o,合起来就是 Hello。结果不同都出在第二步:大于 7F 的字节在 UTF-8、GBK 等编码里代表的字符不一样,所以本页会自动识别编码,并把每种编码的读法并排列出来。
    16进制转字符串为什么是乱码?
    几乎都是因为用错了编码去解码。中文最典型:C4 E3 BA C3 按 GBK 是「你好」,按 UTF-8 却是非法序列;而 E4 BD A0 E5 A5 BD 按 UTF-8 是「你好」,按 GBK 读就成了「浣犲ソ」。看结果下方的编码对照表,读起来通顺的那一行,就是数据原本使用的编码。只有一两个汉字时,自动识别也未必分得清:D2 BB 既是合法 UTF-8(һ),也是 GBK 的「一」,这时请看结果下方给出的 GBK 读法。另外两个原因也值得排除:多了或少了一位16进制数字,会让后面每个字节都错开半个字节;以及把 hexdump 连同偏移列一起粘了进去。如果手上不是16进制,而是已经显示成乱码的文字(比如「浣犲ソ」),直接把文字粘到编码转换与中文乱码恢复
    串口收到的数据显示乱码,切到16进制显示却是对的,怎么回事?
    16进制显示正确,说明波特率、数据位和校验位都没问题——这些设错了,连字节本身都会错。问题出在把字节显示成文字的那一步,常见三种原因。一是数据本来就不是文本:Modbus RTU 这类二进制协议,按文本显示必然是乱码,只能看16进制。二是编码对不上:设备按 UTF-8 发中文,串口调试助手却按 GBK 显示(反过来也一样),「你好」的 UTF-8 字节 E4 BD A0 E5 A5 BD 按 GBK 显示就成了「浣犲ソ」。三是文本里夹着 000D 0A 这类控制字节,被显示成方框或换行。把16进制粘到本页,编码对照表会并排列出 UTF-8 和 GBK 两种读法,控制字节也会显示成 ␀ ␍ ␊。
    16进制转ASCII和16进制转UTF-8有什么区别?
    ASCII 只定义了 007F:字母、数字、标点和控制字符。UTF-8 的设计保证这些字节的含义与 ASCII 完全相同,其他字符则用 80 以上的字节组成多字节序列——带重音的拉丁字母 2 个字节,大多数中日韩文字 3 个字节,emoji 4 个字节。所以纯英文内容做16进制转ASCII和转UTF-8,结果完全一样;一旦出现 80 以上的字节就不同了:只认 ASCII 的转换器无法把这些字节显示成字符,而 UTF-8 能把它们解成完整的 Unicode 字符。007F 每个值对应哪个字符,见 ASCII 码表
    一个汉字转16进制是几个字节?
    取决于编码。UTF-8 里常用汉字占 3 个字节:「你」是 E4 BD A0。GBK 和 GB2312 里占 2 个字节:「你」是 C4 E3。UTF-16 里基本多文种平面的字符占 2 个字节,而且字节顺序有讲究:「你」在 UTF-16LE 是 60 4F,在 UTF-16BE 是 4F 60。基本平面之外的生僻字,UTF-8、UTF-16(代理对)和 GB18030 都要 4 个字节。在「字符串 → 16进制」页签切换编码,就能看到自己的文本占几个字节。
    Python 中16进制怎么转字符串?
    先用 bytes.fromhex() 再解码:bytes.fromhex('48656c6c6f').decode('utf-8') 返回 'Hello'fromhex 允许字节之间有空格,bytes.fromhex('48 65 6c 6c 6f') 同样可以,但带 0x 前缀会抛 ValueError。GBK 数据要用 'gbk' 解码:bytes.fromhex('c4e3bac3').decode('gbk') 返回 '你好',同样的字节按 UTF-8 解码会抛 UnicodeDecodeError。反过来,字符串转16进制用 '你好'.encode('utf-8').hex(),返回 'e4bda0e5a5bd';传入分隔符如 .hex(' ') 可得到空格分隔的结果。
    JavaScript 中16进制怎么转字符串?
    Node.js 里 Buffer.from('48656c6c6f', 'hex').toString('utf8') 返回 'Hello'。注意非法输入:Node 不会抛错,而是在第一个非法的两位组处停下,并悄悄丢掉末尾多出的一位,所以 Buffer.from('486', 'hex') 只有一个字节。浏览器里要自己把字节拼出来再用 TextDecoder,它还能解 GBK:new TextDecoder('gbk').decode(Uint8Array.from('c4e3bac3'.match(/../g), h => parseInt(h, 16))) 返回 '你好'。不要用 charCodeAt() 取字节:'你'.charCodeAt(0).toString(16)'4f60',那是 UTF-16 码元,不是 UTF-8 字节 e4bda0
    C/C++ 中16进制字符串怎么转成字符串?
    每次读两位16进制存进 unsigned char 缓冲区,最后补上结束符:for (size_t i = 0; i < n; i++) sscanf(hex + 2 * i, "%2hhx", &buf[i]); buf[n] = '\0';,其中 nstrlen(hex) / 2。把 hex 设为 48656c6c6f2c20e4b896e7958c,在 UTF-8 终端里打印 buf 得到 Hello, 世界。反方向逐字节打印 printf("%02X ", (unsigned char)s[i])。这个强制转换很关键:在 char 为有符号的平台上,0xE4 这样的字节会被符号扩展,打印成 FFFFFFE4。C++ 里可以逐两位 s.push_back(static_cast<char>(std::stoi(hex.substr(i, 2), nullptr, 16))),同样的 hex 得到 Hello, 世界。
    Java 中16进制怎么转字符串?为什么会打印出 ffffffe4?
    Java 17 及以上一行即可:new String(HexFormat.of().parseHex(hex), StandardCharsets.UTF_8),GBK 数据把字符集换成 Charset.forName("GBK")。反方向打印字节时,常见的问题是出现 ffffffe4:因为 Java 的 byte 是有符号的,而 Integer.toHexString() 接收的是 int。字节 0xE4 在 Java 里存为 -28,扩展成 int 后仍是 -28,toHexString 会把负数按 32 位无符号值打印,于是得到 ffffffe4。这个方法还会去掉前导零,0x0A 输出成 a。改用 String.format("%02x", b),它会把负的 byte 按 8 位无符号值格式化;或者用 Integer.toHexString(b & 0xff) 再补零。Java 17 及以上可以直接用 HexFormat.of().formatHex(bytes) 转整个数组,HexFormat.of().parseHex(hex) 转回来。
    PHP 16进制转字符串用什么函数?
    hex2bin() 把16进制字符串解码成二进制字符串,bin2hex() 反过来:bin2hex('Hello') 返回 48656c6c6f。按 PHP 手册的说明,输入长度为奇数或不是合法16进制时,hex2bin() 返回 false 并产生 E_WARNING,所以调用前要先去掉空格和 0x 前缀。PHP 字符串就是字节,结果沿用原文本的编码——页面是 UTF-8 而数据是 GBK 时,用 mb_convert_encoding() 转一下。
    xxd、hexdump 的输出能直接粘进来转吗?
    可以。偏移列和右侧字符栏会被识别并去掉,输入框下方会提示这一点。这很重要:只会去空格的转换器会把偏移当成数据。本页支持 xxd(含 -u-c-g)、hexdump -C、Go 的 hex.Dumpod -A x -t x1 和 GNU od -t x1z,并会展开 hexdump 和 od 用来代替重复行的 * 行。不带参数的 hexdumpod -x 也能转:它们打印的是 16 位的字而不是字节,在小端机器上字节 48 69 会印成 6948,本页会把每组两个字节换回正确顺序,并按最后一行的偏移去掉奇数长度时补上的那个字节。xxd、hexdump、od 的每种形态都用 600 份随机数据的真实转储测试过。
    16进制位数是奇数是什么意思?
    说明丢了或多了一位,因为每个字节恰好是两位16进制。常见原因:数字转16进制的函数去掉了前导零(a 而不是 0a),复制时截掉了一个字符,或者把 0 错打成字母 O。把所有字节当成一个大整数转16进制(例如 Python 的 hex(int.from_bytes(data, 'big')))会丢掉开头的 0:\r\n 会变成 0xd0a。本页不会替你猜缺的是哪一位——猜错会让后面每个字节都错开半个字节,转出一段看似通顺的错误结果——而是给出两个一键修正:「开头补 0」和「删掉最后一位」,方便对比结果。逐个带前缀的写法如 0x0 0xa 没有问题,每个值都按一个完整字节读。
    粘贴的16进制数据会上传吗?
    不会。转换在浏览器里用 JavaScript 完成,不向服务器发送任何内容,也不保存、不写进页面网址。可以在浏览器开发者工具的「网络」面板里自行确认。这一点对16进制转换尤其重要,因为粘进来的往往是抓包数据、固件内容或生产日志。