使用Java将十六进制转储的字符串表示形式转换为字节数组？答案

【问题标题】：Convert a string representation of a hex dump to a byte array using Java?使用Java将十六进制转储的字符串表示形式转换为字节数组？
【发布时间】：2015-05-26 09:28:11
【问题描述】：

我正在寻找一种将表示十六进制值的长字符串（来自转储）转换为字节数组的方法。

我无法比发帖者the same question here 更好地表达它。

但为了保持原创，我会用我自己的方式来表达它：假设我有一个字符串"00A0BF"，我想将其解释为

byte[] {0x00,0xA0,0xBf}

我该怎么办？

我是一名 Java 新手，最后使用 BigInteger 并注意前导十六进制零。但我认为它很丑，我确信我错过了一些简单的东西。

【问题讨论】：

另见stackoverflow.com/questions/9655181/…。
我已经驯服了BigInteger here。
FWIW String.getBytes() 不会像你想象的那样工作。不得不以艰难的方式学习这一点。 if ("FF".getBytes() != "ff".getBytes()) { System.out.println("Try again"); }

标签： java byte hex dump

【解决方案1】：

编辑：正如@mmyers 所指出的，此方法不适用于包含与设置了高位（“80”-“FF”）的字节相对应的子字符串的输入。解释在Bug ID: 6259307 Byte.parseByte not working as advertised in the SDK Documentation。

public static final byte[] fromHexString(final String s) {
    byte[] arr = new byte[s.length()/2];
    for ( int start = 0; start < s.length(); start += 2 )
    {
        String thisByte = s.substring(start, start+2);
        arr[start/2] = Byte.parseByte(thisByte, 16);
    }
    return arr;
}

【讨论】：

关闭，但此方法在给定输入“00A0BBF”上失败。见bugs.sun.com/bugdatabase/view_bug.do?bug_id=6259307。
奇怪的是它不处理“9C”
@mmyers：哇。这不好。很抱歉造成混乱。 @ravigad：9C 也有同样的问题，因为在这种情况下设置了高位。
(byte)Short.parseShort(thisByte, 16) 解决了这个问题

【解决方案2】：

更新 (2021) - Java 17 现在包括 java.util.HexFormat（仅用了 25 年）：

HexFormat.of().parseHex(s)

对于旧版本的 Java：

这是我认为比迄今为止发布的任何解决方案都更好的解决方案：

/* s must be an even-length string. */
public static byte[] hexStringToByteArray(String s) {
    int len = s.length();
    byte[] data = new byte[len / 2];
    for (int i = 0; i < len; i += 2) {
        data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
                             + Character.digit(s.charAt(i+1), 16));
    }
    return data;
}

改进的原因：

前导零（与 BigInteger 不同）和负字节值（与 Byte.parseByte 不同）安全
不将 String 转换为 char[]，或为每个字节创建 StringBuilder 和 String 对象。
没有可能不可用的库依赖项

随意通过assert添加参数检查，如果参数不知道是安全的，则添加例外。

【讨论】：

你能举一个解码错误的例子，或者解释它是怎么错的吗？
它不适用于字符串“0”。它抛出一个 java.lang.StringIndexOutOfBoundsException
"0" 不是有效输入。每个字节需要两个十六进制数字。正如答案所指出的，“请随意添加参数检查......如果不知道该参数是安全的。”
javax.xml.bind.DatatypeConverter.parseHexBinary(hexString) 在我的微测试中似乎比上述解决方案快 20% 左右（不管它们值多少钱），以及正确抛出异常无效输入（例如，“gg”不是有效的 hexString，但会使用建议的解决方案返回 -77）。
@DaedalusAlpha 这取决于你的具体情况，但通常我发现这样的事情最好快速而响亮地失败，这样你就可以修正你的假设，而不是默默地返回不正确的数据。

【解决方案3】：

commons-codec 中的 Hex 类应该会为你做这些。

http://commons.apache.org/codec/

import org.apache.commons.codec.binary.Hex;
...
byte[] decoded = Hex.decodeHex("00A0BF");
// 0x00 0xA0 0xBF

【讨论】：

这看起来也不错。见 org.apache.commons.codec.binary.Hex.decodeHex()
这很有趣。但我发现他们的解决方案很难遵循。与您提出的建议相比，它有什么优势（除了检查偶数个字符）吗？

【解决方案4】：

我知道这是一个非常古老的线程，但仍然想增加我的一分钱。

如果我真的需要编写一个简单的十六进制字符串到二进制转换器，我想这样做。

public static byte[] hexToBinary(String s){

  /*
   * skipped any input validation code
   */

  byte[] data = new byte[s.length()/2];

  for( int i=0, j=0; 
       i<s.length() && j<data.length; 
       i+=2, j++)
  {
     data[j] = (byte)Integer.parseInt(s.substring(i, i+2), 16);
  }

  return data;
}

【讨论】：

【解决方案5】：

聚会迟到了，但我已将 DaveL 的上述答案合并到一个具有相反动作的类中 - 以防万一它有帮助。

public final class HexString {
    private static final char[] digits = "0123456789ABCDEF".toCharArray();

    private HexString() {}

    public static final String fromBytes(final byte[] bytes) {
        final StringBuilder buf = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            buf.append(HexString.digits[(bytes[i] >> 4) & 0x0f]);
            buf.append(HexString.digits[bytes[i] & 0x0f]);
        }
        return buf.toString();
    }

    public static final byte[] toByteArray(final String hexString) {
        if ((hexString.length() % 2) != 0) {
            throw new IllegalArgumentException("Input string must contain an even number of characters");
        }
        final int len = hexString.length();
        final byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4)
                    + Character.digit(hexString.charAt(i + 1), 16));
        }
        return data;
    }
}

还有JUnit测试类：

public class TestHexString {

    @Test
    public void test() {
        String[] tests = {"0FA1056D73", "", "00", "0123456789ABCDEF", "FFFFFFFF"};

        for (int i = 0; i < tests.length; i++) {
            String in = tests[i];
            byte[] bytes = HexString.toByteArray(in);
            String out = HexString.fromBytes(bytes);
            System.out.println(in); //DEBUG
            System.out.println(out); //DEBUG
            Assert.assertEquals(in, out);

        }

    }

}

【讨论】：

【解决方案6】：

如果您喜欢 Java 8 流作为您的编码风格，那么这可以仅使用 JDK 原语来实现。

String hex = "0001027f80fdfeff";

byte[] converted = IntStream.range(0, hex.length() / 2)
    .map(i -> Character.digit(hex.charAt(i * 2), 16) << 4 | Character.digit(hex.charAt((i * 2) + 1), 16))
    .collect(ByteArrayOutputStream::new,
             ByteArrayOutputStream::write,
             (s1, s2) -> s1.write(s2.toByteArray(), 0, s2.size()))
    .toByteArray();

如果您不介意捕获IOException，可以省略收集器连接函数中的, 0, s2.size() 参数。

【讨论】：

【解决方案7】：

您现在可以在guava 中使用BaseEncoding 来完成此操作。

BaseEncoding.base16().decode(string);

要反转它使用

BaseEncoding.base16().encode(bytes);

【讨论】：

【解决方案8】：

单行：

import javax.xml.bind.DatatypeConverter;

public static String toHexString(byte[] array) {
    return DatatypeConverter.printHexBinary(array);
}

public static byte[] toByteArray(String s) {
    return DatatypeConverter.parseHexBinary(s);
}

警告：

在 Java 9 Jigsaw 中，这不再是（默认）java.se 根目录的一部分设置，因此除非您指定，否则它将导致 ClassNotFoundException --add-modules java.se.ee（感谢@eckes）
在 Android 上不可用（感谢Fabian 注意到这一点），但如果您的系统由于某种原因缺少javax.xml，您可以只使用take the source code。感谢@Bert Regelink 提取源代码。

【讨论】：

恕我直言，这应该是公认的/最佳答案，因为它很短且干净（与@DaveL 的答案不同）并且不需要任何外部库（如 skaffman 的答案）。另外，。
例如，datatypeconverter 类在 android 中不可用。
警告：在 Java 9 Jigsaw 中，这不再是（默认）java.se 根集的一部分，因此除非您指定 --add-modules java.se.ee，否则它将导致 ClassNotFoundException
@dantebarba 我认为javax.xml.bind.DatatypeConverter 已经提供了一种编码/解码 Base64 数据的方法。请参阅parseBase64Binary() 和printBase64Binary()。
为了补充DataTypeConverter 的问题，Java SE 11 完全删除了 JAXB API，现在只包含在 Java EE 中。您还可以将其添加为 Maven 依赖项，如下所示：stackoverflow.com/a/43574427/7347751

【解决方案9】：

我的正式解决方案：

/**
 * Decodes a hexadecimally encoded binary string.
 * <p>
 * Note that this function does <em>NOT</em> convert a hexadecimal number to a
 * binary number.
 *
 * @param hex Hexadecimal representation of data.
 * @return The byte[] representation of the given data.
 * @throws NumberFormatException If the hexadecimal input string is of odd
 * length or invalid hexadecimal string.
 */
public static byte[] hex2bin(String hex) throws NumberFormatException {
    if (hex.length() % 2 > 0) {
        throw new NumberFormatException("Hexadecimal input string must have an even length.");
    }
    byte[] r = new byte[hex.length() / 2];
    for (int i = hex.length(); i > 0;) {
        r[i / 2 - 1] = (byte) (digit(hex.charAt(--i)) | (digit(hex.charAt(--i)) << 4));
    }
    return r;
}

private static int digit(char ch) {
    int r = Character.digit(ch, 16);
    if (r < 0) {
        throw new NumberFormatException("Invalid hexadecimal string: " + ch);
    }
    return r;
}

类似于PHP hex2bin() Function，但采用 Java 风格。

示例：

String data = new String(hex2bin("6578616d706c65206865782064617461"));
// data value: "example hex data"

【讨论】：

【解决方案10】：

值得一提的是，这是另一个支持奇数长度字符串的版本，无需使用字符串连接。

public static byte[] hexStringToByteArray(String input) {
    int len = input.length();

    if (len == 0) {
        return new byte[] {};
    }

    byte[] data;
    int startIdx;
    if (len % 2 != 0) {
        data = new byte[(len / 2) + 1];
        data[0] = (byte) Character.digit(input.charAt(0), 16);
        startIdx = 1;
    } else {
        data = new byte[len / 2];
        startIdx = 0;
    }

    for (int i = startIdx; i < len; i += 2) {
        data[(i + 1) / 2] = (byte) ((Character.digit(input.charAt(i), 16) << 4)
                + Character.digit(input.charAt(i+1), 16));
    }
    return data;
}

【讨论】：

【解决方案11】：

在android中，如果你使用的是十六进制，你可以试试okio。

简单用法：

byte[] bytes = ByteString.decodeHex("c000060000").toByteArray();

结果将是

[-64, 0, 6, 0, 0]

【讨论】：

我测试了许多不同的方法，但这个至少快一倍！
这是山羊。

【解决方案12】：

对我来说这是解决方案，HEX="FF01" 然后拆分为 FF(255) 和 01(01)

private static byte[] BytesEncode(String encoded) {
    //System.out.println(encoded.length());
    byte result[] = new byte[encoded.length() / 2];
    char enc[] = encoded.toUpperCase().toCharArray();
    String curr = "";
    for (int i = 0; i < encoded.length(); i=i+2) {
        curr = encoded.substring(i,i+2);
        System.out.println(curr);
        if(i==0){
            result[i]=((byte) Integer.parseInt(curr, 16));
        }else{
            result[i/2]=((byte) Integer.parseInt(curr, 16));
        }

    }
    return result;
}

【讨论】：

这个问题已经回答了一段时间，并且有几个不错的选择；不幸的是，您的回答目前没有提供任何显着改进的价值。

【解决方案13】：

基于 op 投票的解决方案，以下应该更有效：

  public static byte [] hexStringToByteArray (final String s) {
    if (s == null || (s.length () % 2) == 1)
      throw new IllegalArgumentException ();
    final char [] chars = s.toCharArray ();
    final int len = chars.length;
    final byte [] data = new byte [len / 2];
    for (int i = 0; i < len; i += 2) {
      data[i / 2] = (byte) ((Character.digit (chars[i], 16) << 4) + Character.digit (chars[i + 1], 16));
    }
    return data;
  }

因为：初始转换为 char 数组省去了 charAt 中的长度检查

【讨论】：

【解决方案14】：

Bert Regelink 提供的代码根本不起作用。请尝试以下操作：

import javax.xml.bind.DatatypeConverter;
import java.io.*;

public class Test
{  
    @Test
    public void testObjectStreams( ) throws IOException, ClassNotFoundException
    {     
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);

            String stringTest = "TEST";
            oos.writeObject( stringTest );

            oos.close();
            baos.close();

            byte[] bytes = baos.toByteArray();
            String hexString = DatatypeConverter.printHexBinary( bytes);
            byte[] reconvertedBytes = DatatypeConverter.parseHexBinary(hexString);

            assertArrayEquals( bytes, reconvertedBytes );

            ByteArrayInputStream bais = new ByteArrayInputStream(reconvertedBytes);
            ObjectInputStream ois = new ObjectInputStream(bais);

            String readString = (String) ois.readObject();

            assertEquals( stringTest, readString);
        }
    }

【讨论】：

这确实是一个不同的问题，可能属于另一个线程。

【解决方案15】：

单行：

import javax.xml.bind.DatatypeConverter;

public static String toHexString(byte[] array) {
    return DatatypeConverter.printHexBinary(array);
}

public static byte[] toByteArray(String s) {
    return DatatypeConverter.parseHexBinary(s);
}

对于那些对来自FractalizeR 的 One-liners 背后的实际代码感兴趣的人（我需要它，因为 javax.xml.bind 不适用于 Android（默认情况下）），这个来自com.sun.xml.internal.bind.DatatypeConverterImpl.java：

public byte[] parseHexBinary(String s) {
    final int len = s.length();

    // "111" is not a valid hex encoding.
    if( len%2 != 0 )
        throw new IllegalArgumentException("hexBinary needs to be even-length: "+s);

    byte[] out = new byte[len/2];

    for( int i=0; i<len; i+=2 ) {
        int h = hexToBin(s.charAt(i  ));
        int l = hexToBin(s.charAt(i+1));
        if( h==-1 || l==-1 )
            throw new IllegalArgumentException("contains illegal character for hexBinary: "+s);

        out[i/2] = (byte)(h*16+l);
    }

    return out;
}

private static int hexToBin( char ch ) {
    if( '0'<=ch && ch<='9' )    return ch-'0';
    if( 'A'<=ch && ch<='F' )    return ch-'A'+10;
    if( 'a'<=ch && ch<='f' )    return ch-'a'+10;
    return -1;
}

private static final char[] hexCode = "0123456789ABCDEF".toCharArray();

public String printHexBinary(byte[] data) {
    StringBuilder r = new StringBuilder(data.length*2);
    for ( byte b : data) {
        r.append(hexCode[(b >> 4) & 0xF]);
        r.append(hexCode[(b & 0xF)]);
    }
    return r.toString();
}

【讨论】：

DatatypeConverter 默认在 Java 9 中也不可用。危险的是使用它的代码将在 Java 1.8 或更早版本下编译（Java 9 的源设置更早），但在没有“--add-modules java.se.ee”的情况下在 Java 9 下会出现运行时异常。

【解决方案16】：

我发现 Kernel Panic 的解决方案对我最有用，但如果十六进制字符串是奇数，就会遇到问题。这样解决了：

boolean isOdd(int value)
{
    return (value & 0x01) !=0;
}

private int hexToByte(byte[] out, int value)
{
    String hexVal = "0123456789ABCDEF"; 
    String hexValL = "0123456789abcdef";
    String st = Integer.toHexString(value);
    int len = st.length();
    if (isOdd(len))
        {
        len+=1; // need length to be an even number.
        st = ("0" + st);  // make it an even number of chars
        }
    out[0]=(byte)(len/2);
    for (int i =0;i<len;i+=2)
    {
        int hh = hexVal.indexOf(st.charAt(i));
            if (hh == -1)  hh = hexValL.indexOf(st.charAt(i));
        int lh = hexVal.indexOf(st.charAt(i+1));
            if (lh == -1)  lh = hexValL.indexOf(st.charAt(i+1));
        out[(i/2)+1] = (byte)((hh << 4)|lh);
    }
    return (len/2)+1;
}

我将一些十六进制数添加到数组中，因此我将引用传递给我正在使用的数组，以及我需要转换的 int 并返回下一个十六进制数的相对位置。所以最终的字节数组有[0]个十六进制对，[1...]个十六进制对，然后是对的数量......

【讨论】：

【解决方案17】：

HexBinaryAdapter 提供在String 和byte[] 之间编组和解组的能力。

import javax.xml.bind.annotation.adapters.HexBinaryAdapter;

public byte[] hexToBytes(String hexString) {
     HexBinaryAdapter adapter = new HexBinaryAdapter();
     byte[] bytes = adapter.unmarshal(hexString);
     return bytes;
}

这只是我输入的一个示例...我实际上只是按原样使用它，不需要单独创建一个方法来使用它。

【讨论】：

只有当输入字符串（hexString）有偶数个字符时才有效。否则：线程“main” java.lang.IllegalArgumentException 中的异常：hexBinary 需要偶数长度：
哦，感谢您指出这一点。用户真的不应该有奇数个字符，因为字节数组表示为 {0x00,0xA0,0xBf}。每个字节有两个十六进制数字或半字节。所以任何数量的字节应该总是有偶数个字符。感谢您提及这一点。
您可以直接使用 java.xml.bind.DatatypeConverter.parseHexBinary(hexString) 而不是使用 HexBinaryAdapter（反过来调用 DatatypeConverter）。这样您就不必创建适配器实例对象（因为 DatatypeConverter 方法是静态的）。
javax.xml.bind.* 在 Java 9 中不再可用。危险的是使用它的代码将在 Java 1.8 或更早版本下编译（Java 9 的源设置为更早版本），但得到一个在 Java 9 下运行的运行时异常。

【解决方案18】：

我喜欢 Character.digit 解决方案，但这是我的解决方法

public byte[] hex2ByteArray( String hexString ) {
    String hexVal = "0123456789ABCDEF";
    byte[] out = new byte[hexString.length() / 2];

    int n = hexString.length();

    for( int i = 0; i < n; i += 2 ) {
        //make a bit representation in an int of the hex value 
        int hn = hexVal.indexOf( hexString.charAt( i ) );
        int ln = hexVal.indexOf( hexString.charAt( i + 1 ) );

        //now just shift the high order nibble and add them together
        out[i/2] = (byte)( ( hn << 4 ) | ln );
    }

    return out;
}

【讨论】：

【解决方案19】：

public static byte[] hex2ba(String sHex) throws Hex2baException {
    if (1==sHex.length()%2) {
        throw(new Hex2baException("Hex string need even number of chars"));
    }

    byte[] ba = new byte[sHex.length()/2];
    for (int i=0;i<sHex.length()/2;i++) {
        ba[i] = (Integer.decode(
                "0x"+sHex.substring(i*2, (i+1)*2))).byteValue();
    }
    return ba;
}

【讨论】：

【解决方案20】：

java.math 中的BigInteger() 方法非常慢且不推荐使用。

Integer.parseInt(HEXString, 16)

可能会导致某些字符出现问题转换为数字/整数

一种有效的方法：

Integer.decode("0xXX") .byteValue()

功能：

public static byte[] HexStringToByteArray(String s) {
    byte data[] = new byte[s.length()/2];
    for(int i=0;i < s.length();i+=2) {
        data[i/2] = (Integer.decode("0x"+s.charAt(i)+s.charAt(i+1))).byteValue();
    }
    return data;
}

玩得开心，祝你好运

【讨论】：

【解决方案21】：

其实我觉得 BigInteger 的解决方案很不错：

new BigInteger("00A0BF", 16).toByteArray();

编辑：前导零不安全，如海报所述。

【讨论】：

我一开始也是这么想的。感谢您记录它 - 我只是想我应该......它做了一些我不太理解的奇怪事情 - 比如省略一些前导 0x00 并且还在 156 字节字符串中混合了 1 个字节的顺序正在玩。
这是一个关于前导 0 的好点。我不确定我是否相信它会混淆字节顺序，并且很想看到它被演示。
是的，我一说出来，我也不相信我 :) 我比较了 BigInteger 中的字节数组与 mmyers'fromHexString 和（没有 0x00）与有问题的字符串- 他们是相同的。 “混淆”确实发生了，但它可能是别的东西。我明天再仔细看看
BigInteger 的问题是必须有一个“符号位”。如果前导字节设置了高位，则生成的字节数组在第一个位置有一个额外的 0。但仍然 +1。

【解决方案22】：

这是一个实际可行的方法（基于之前的几个半正确答案）：

private static byte[] fromHexString(final String encoded) {
    if ((encoded.length() % 2) != 0)
        throw new IllegalArgumentException("Input string must contain an even number of characters");

    final byte result[] = new byte[encoded.length()/2];
    final char enc[] = encoded.toCharArray();
    for (int i = 0; i < enc.length; i += 2) {
        StringBuilder curr = new StringBuilder(2);
        curr.append(enc[i]).append(enc[i + 1]);
        result[i/2] = (byte) Integer.parseInt(curr.toString(), 16);
    }
    return result;
}

我能看到的唯一可能的问题是输入字符串是否非常长；调用 toCharArray() 会复制字符串的内部数组。

编辑：哦，顺便说一下，字节是用 Java 签名的，所以你的输入字符串转换为 [0, -96, -65] 而不是 [0, 160, 191]。但你可能已经知道了。

【讨论】：

谢谢迈克尔 - 你是一个救生员！处理 BlackBerry 项目并尝试将字节的字符串表示形式转换回字节......使用 RIM 的“Byte.parseByte(byteString, 16)”方法。不断抛出 NumberFormatExcpetion。花了几个小时努力找出原因。您对“Integer.praseInt()”的建议起到了作用。再次感谢！！

【解决方案23】：

我想我会为你做的。我从一个以字符串形式返回数据的类似函数将它拼凑在一起：

private static byte[] decode(String encoded) {
    byte result[] = new byte[encoded/2];
    char enc[] = encoded.toUpperCase().toCharArray();
    StringBuffer curr;
    for (int i = 0; i < enc.length; i += 2) {
        curr = new StringBuffer("");
        curr.append(String.valueOf(enc[i]));
        curr.append(String.valueOf(enc[i + 1]));
        result[i] = (byte) Integer.parseInt(curr.toString(), 16);
    }
    return result;
}

【讨论】：

首先，您不需要将字符串转换为大写。其次，可以将字符直接附加到 StringBuffer，这应该会更有效。
就此而言，您不需要任何 StringBuffer（自 2004 年以来最好是 StringBuilder），只需执行 new String (enc, i, 2)

【解决方案24】：

我一直使用类似的方法

public static final byte[] fromHexString(final String s) {
    String[] v = s.split(" ");
    byte[] arr = new byte[v.length];
    int i = 0;
    for(String val: v) {
        arr[i++] =  Integer.decode("0x" + val).byteValue();

    }
    return arr;
}

此方法会根据空格分隔的十六进制值进行拆分，但根据任何其他条件（例如将字符串拆分为两个字符的分组）并不难。

【讨论】：

字符串连接是不必要的。只需使用 Integer.valueOf(val, 16)。
我之前尝试过使用这样的基数转换，但结果好坏参半
谢谢 - 奇怪的是它可以很好地处理这个字符串：“9C001C”或“001C21”并且失败了这个：“9C001C21”线程“main”中的异常java.lang.NumberFormatException：对于输入字符串： java.lang.NumberFormatException.forInputString（未知来源）处的“9C001C21”
（这并不比Byte/byte的情况更奇怪：最高位设置不带前导-）