Fatal编程技术网
  • java/
  • 在Java中，如何将字节数组转换为十六进制数字字符串，同时保留前导零？

在Java中，如何将字节数组转换为十六进制数字字符串，同时保留前导零？

java

在Java中，如何将字节数组转换为十六进制数字字符串，同时保留前导零？,java,md5,hex,Java,Md5,Hex,我正在使用一些示例java代码来制作md5哈希。其中一部分将结果从字节转换为十六进制数字字符串： byte messageDigest[] = algorithm.digest(); StringBuffer hexString = new StringBuffer(); for (int i=0;i<messageDigest.length;i++) { hexString.append(Integer.toHexString(0xFF & messageDig

我正在使用一些示例java代码来制作md5哈希。其中一部分将结果从字节转换为十六进制数字字符串：

byte messageDigest[] = algorithm.digest();     
StringBuffer hexString = new StringBuffer();
for (int i=0;i<messageDigest.length;i++) {
    hexString.append(Integer.toHexString(0xFF & messageDigest[i]));
    }

byte messageDigest[]=algorithm.digest（）；
StringBuffer hexString=新的StringBuffer（）；

对于（int i=0；i这是我用于MD5哈希的内容：


public static String getMD5(String filename)
        throws NoSuchAlgorithmException, IOException {
    MessageDigest messageDigest = 
        java.security.MessageDigest.getInstance("MD5");

    InputStream in = new FileInputStream(filename);

    byte [] buffer = new byte[8192];
    int len = in.read(buffer, 0, buffer.length);

    while (len > 0) {
        messageDigest.update(buffer, 0, len);
        len = in.read(buffer, 0, buffer.length);
    }
    in.close();

    return new BigInteger(1, messageDigest.digest()).toString(16);
}



编辑：我已经测试过了，我注意到尾随的零也被切掉了。但这只能发生在开始时，因此您可以相应地与预期的长度和填充进行比较。
一个简单的方法是检查Integer.toHexString（）输出了多少位数字
并在需要时为每个字节添加前导零。类似如下：

public static String toHexString(byte[] bytes) {
    StringBuilder hexString = new StringBuilder();

    for (int i = 0; i < bytes.length; i++) {
        String hex = Integer.toHexString(0xFF & bytes[i]);
        if (hex.length() == 1) {
            hexString.append('0');
        }
        hexString.append(hex);
    }

    return hexString.toString();
}

公共静态字符串到HexString（字节[]字节）{
StringBuilder hexString=新的StringBuilder（）；
for（int i=0；i
这是已知的最短解决方案。如果可以将字节数组转换为数值，
String.format
可以同时将其转换为十六进制字符串。

byte messageDigest[]=algorithm.digest（）；

byte messageDigest[] = algorithm.digest();
StringBuffer hexString = new StringBuffer();
for (int i = 0; i < messageDigest.length; i++) {
    String hexByte = Integer.toHexString(0xFF & messageDigest[i]);
    int numDigits = 2 - hexByte.length();
    while (numDigits-- > 0) {
        hexString.append('0');
    }
    hexString.append(hexByte);
}


StringBuffer hexString=新的StringBuffer（）；
for（int i=0；i0）{
附加（'0'）；
}
附加（hexByte）；
}
从中签出

这个解决方案比较老，应该是内存有效的

public static String toHexString(byte bytes[]) {
    if (bytes == null) {
        return null;
    }

    StringBuffer sb = new StringBuffer();
    for (int iter = 0; iter < bytes.length; iter++) {
        byte high = (byte) ( (bytes[iter] & 0xf0) >> 4);
        byte low =  (byte)   (bytes[iter] & 0x0f);
        sb.append(nibble2char(high));
        sb.append(nibble2char(low));
    }

    return sb.toString();
}

private static char nibble2char(byte b) {
    byte nibble = (byte) (b & 0x0f);
    if (nibble < 10) {
        return (char) ('0' + nibble);
    }
    return (char) ('a' + nibble - 10);
}

公共静态字符串到十六进制字符串（字节[]）{
如果（字节==null）{
返回null；
}
StringBuffer sb=新的StringBuffer（）；
for（int-iter=0；iter>4）；
字节低=（字节）（字节[iter]&0x0f）；
某人追加（一小口（高））；
sb.追加（一小口（低））；
}
使某人返回字符串（）；
}
私有静态字符nibble2char（字节b）{
字节半字节=（字节）（b&0x0f）；
if（半字节<10）{
返回（字符）（'0'+半字节）；
}
返回（字符）（'a'+半字节-10）；
}
您可以使用下面的一个。我使用前导零字节和初始负字节对此进行了测试

public static String toHex(byte[] bytes) {
    BigInteger bi = new BigInteger(1, bytes);
    return String.format("%0" + (bytes.length << 1) + "X", bi);
}

公共静态字符串toHex（字节[]字节）{
BigInteger bi=新的BigInteger（1，字节）；
返回String.format（“%0”+（bytes.length另一个选项


public static String toHexString(byte[]bytes) {
    StringBuilder sb = new StringBuilder(bytes.length*2);
    for(byte b: bytes)
      sb.append(Integer.toHexString(b+0x800).substring(1));
    return sb.toString();
}



<>我发现Integer.toHexString有点慢。如果你转换了很多字节，你可能需要考虑建立一个包含“00”…“FF”的字符串数组，并使用整型数作为索引。

hexString.append(hexArray[0xFF & messageDigest[i]]);


这会更快并确保正确的长度。只需要字符串数组：


String[] hexArray = {
"00","01","02","03","04","05","06","07","08","09","0A","0B","0C","0D","0E","0F",
"10","11","12","13","14","15","16","17","18","19","1A","1B","1C","1D","1E","1F",
"20","21","22","23","24","25","26","27","28","29","2A","2B","2C","2D","2E","2F",
"30","31","32","33","34","35","36","37","38","39","3A","3B","3C","3D","3E","3F",
"40","41","42","43","44","45","46","47","48","49","4A","4B","4C","4D","4E","4F",
"50","51","52","53","54","55","56","57","58","59","5A","5B","5C","5D","5E","5F",
"60","61","62","63","64","65","66","67","68","69","6A","6B","6C","6D","6E","6F",
"70","71","72","73","74","75","76","77","78","79","7A","7B","7C","7D","7E","7F",
"80","81","82","83","84","85","86","87","88","89","8A","8B","8C","8D","8E","8F",
"90","91","92","93","94","95","96","97","98","99","9A","9B","9C","9D","9E","9F",
"A0","A1","A2","A3","A4","A5","A6","A7","A8","A9","AA","AB","AC","AD","AE","AF",
"B0","B1","B2","B3","B4","B5","B6","B7","B8","B9","BA","BB","BC","BD","BE","BF",
"C0","C1","C2","C3","C4","C5","C6","C7","C8","C9","CA","CB","CC","CD","CE","CF",
"D0","D1","D2","D3","D4","D5","D6","D7","D8","D9","DA","DB","DC","DD","DE","DF",
"E0","E1","E2","E3","E4","E5","E6","E7","E8","E9","EA","EB","EC","ED","EE","EF",
"F0","F1","F2","F3","F4","F5","F6","F7","F8","F9","FA","FB","FC","FD","FE","FF"};



我一直在寻找同样的东西…这里有一些好主意，但我运行了一些微基准测试。我发现以下是最快的（修改自Ayman的上面，大约2倍于这个速度，大约比Steve的略高于这个速度快50%）：

编辑：Oops-忽略了这与kgiannakakis的基本相同，因此可能会去掉前导0。但是，将其修改为以下内容，它仍然是最快的：


public static String hash(String text, String algorithm)
        throws NoSuchAlgorithmException {
    byte[] hash = MessageDigest.getInstance(algorithm).digest(text.getBytes());
    BigInteger bi = new BigInteger(1, hash);
    String result = bi.toString(16);
    if (result.length() % 2 != 0) {
        return "0" + result;
    }
    return result;
}



看来concat和append函数可能真的很慢。以下内容对我来说要快得多（比我之前的文章）。在构建输出时更改为字符数组是加快速度的关键因素。我没有与Brandon DuRette建议的Hex.encodeHex进行比较


public static String toHexString(byte[] bytes) {
    char[] hexArray = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    char[] hexChars = new char[10000000];
    int c = 0;
    int v;
    for ( j = 0; j < bytes.length; j++ ) {
        v = bytes[j] & 0xFF;
        hexChars[c] = hexArray[v/16];
        c++;
        hexChars[c] = hexArray[v%16];
        c++;
    }
    return new String(hexChars, 0, c); }



公共静态字符串到HexString（字节[]字节）{
char[]hexArray={'0'，'1'，'2'，'3'，'4'，'5'，'6'，'7'，'8'，'9'，'A'，'B'，'C'，'D'，'E'，'F'}；
char[]hexChars=新字符[10000000]；
int c=0；
INTV；
对于（j=0；j
我喜欢史蒂夫提交的资料，但他本可以不用几个变量，在这个过程中节省几行


public static String toHexString(byte[] bytes) {
    char[] hexArray = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    char[] hexChars = new char[bytes.length * 2];
    int v;
    for ( int j = 0; j < bytes.length; j++ ) {
        v = bytes[j] & 0xFF;
        hexChars[j*2] = hexArray[v/16];
        hexChars[j*2 + 1] = hexArray[v%16];
    }
    return new String(hexChars);
}



公共静态字符串到HexString（字节[]字节）{
char[]hexArray={'0'，'1'，'2'，'3'，'4'，'5'，'6'，'7'，'8'，'9'，'A'，'B'，'C'，'D'，'E'，'F'}；
char[]hexChars=新字符[bytes.length*2]；
INTV；
对于（int j=0；j


我喜欢的是，它很容易准确地看到它在做什么（而不是依赖于一些神奇的BigInteger黑盒转换）你也不用担心像前导零之类的角点。这个例程将每4位字节转换成一个十六进制字符。它使用表查找，所以它可能很快。如果你用按位移位和和替换v/16和v%16，它可能会更快，但我现在懒得测试它。
I为了保持前导零，这里是Paul建议的一个小变化（例如md5哈希）：


static String toHex(byte[] digest) {
    StringBuilder sb = new StringBuilder();
    for (byte b : digest) {
        sb.append(String.format("%1$02X", b));
    }

    return sb.toString();
}



哎呀，这看起来比Ayman建议的要差，很抱歉，上面所有提供删除前导零的片段的解决方案都是错误的


static String toHex(byte[] digest) {
    String digits = "0123456789abcdef";
    StringBuilder sb = new StringBuilder(digest.length * 2);
    for (byte b : digest) {
        int bi = b & 0xff;
        sb.append(digits.charAt(bi >> 4));
        sb.append(digits.charAt(bi & 0xf));
    }
    return sb.toString();
}



byte messageDigest[] = algorithm.digest();
for (int i = 0; i < messageDigest.length; i++) {
    hexString.append(Integer.toHexString(0xFF & messageDigest[i]));
}    



byte messageDigest[]=algorithm.digest（）；
for（int i=0；i

根据这段代码，从字节数组中提取8位
迭代，转换为整数（因为integer.tohextString函数
int作为参数），然后将该整数转换为相应的哈希
例如，如果二进制文件中有00000001 00000001，根据
在代码中，hexString变量将0x11作为十六进制值
正确的v

static String toHex(byte[] digest) {
    StringBuilder sb = new StringBuilder();
    for (byte b : digest) {
        sb.append(String.format("%1$02X", b));
    }

    return sb.toString();
}



public static String MD5hash(String text) throws NoSuchAlgorithmException {
    byte[] hash = MessageDigest.getInstance("MD5").digest(text.getBytes());
    return String.format("%032x",new BigInteger(1, hash));
}



static String toHex(byte[] digest) {
    String digits = "0123456789abcdef";
    StringBuilder sb = new StringBuilder(digest.length * 2);
    for (byte b : digest) {
        int bi = b & 0xff;
        sb.append(digits.charAt(bi >> 4));
        sb.append(digits.charAt(bi & 0xf));
    }
    return sb.toString();
}



byte messageDigest[] = algorithm.digest();
for (int i = 0; i < messageDigest.length; i++) {
    hexString.append(Integer.toHexString(0xFF & messageDigest[i]));
}    



byte messageDigest[] = algorithm.digest();
for (int i = 0; i < messageDigest.length; i++) {
    int temp=0xFF & messageDigest[i];
    String s=Integer.toHexString(temp);
    if(temp<=0x0F){
        s="0"+s;
    }
    hexString.append(s);
}



HexBin.encode(messageDigest).toLowerCase();



String hex = (new HexBinaryAdapter()).marshal(md5.digest(YOUR_STRING.getBytes()))



byte[] digest = new byte[16];       

Formatter fmt = new Formatter();    
for (byte b : digest) { 
  fmt.format("%02X", b);    
}

fmt.toString()



byte bytes[] = {(byte)0, (byte)0, (byte)134, (byte)0, (byte)61};
String hex = javax.xml.bind.DatatypeConverter.printHexBinary(bytes);



public String toString(byte b){
    final char[] Hex = new String("0123456789ABCDEF").toCharArray();
    return  "0x"+ Hex[(b & 0xF0) >> 4]+ Hex[(b & 0x0F)];
}



public static String toHexString(byte[] bytes) {
    char[] hexArray = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    char[] hexChars = new char[bytes.length * 2];
    int v;
    for ( int j = 0; j < bytes.length; j++ ) {
        v = bytes[j] & 0xFF;
        hexChars[j*2] = hexArray[v/16];
        hexChars[j*2 + 1] = hexArray[v%16];
    }
    return new String(hexChars);
}



    StringBuilder builder = new StringBuilder();
    for (byte b : bytes)
    {
        builder.append(Character.forDigit(b/16, 16));
        builder.append(Character.forDigit(b % 16, 16));
    }
    System.out.println(builder.toString());



    // Create MD5 Hash
    MessageDigest digest = java.security.MessageDigest.getInstance("MD5");
    digest.update(s.getBytes());
    byte[] md5sum = digest.digest();
    BigInteger bigInt = new BigInteger(1, md5sum);
    String stringMD5 = bigInt.toString(16);
    // Fill to 32 chars
    stringMD5 = String.format("%32s", stringMD5).replace(' ', '0');
    return stringMD5;



BaseEncoding.base16().encode( bytes );



byte[] bytes = new byte[] { 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
BaseEncoding.base16().lowerCase().withSeparator( ":", 2 ).encode( bytes );
// "0a:0b:0c:0d:0e:0f"



StringWriter sw = new StringWriter();
com.sun.corba.se.impl.orbutil.HexOutputStream hex = new com.sun.corba.se.impl.orbutil.HexOutputStream(sw);
hex.write(byteArray);
System.out.println(sw.toString());



md5sum = String.format("%032x", new BigInteger(1, md.digest()));



byte[] digest = algorithm.digest();
StringBuilder byteContet = new StringBuilder();
for(byte b: digest){
 byteContent = String.format("%02x",b);
 byteContent.append(byteContent);
}