Java将字节数组转化为16进制字符串的多种方案

       很多时候我们需要将字节数组转化为16进制字符串来保存，尤其在很多加密的场景中，例如保存密钥等。因为字节数组，除了写入文件或者以二进制的形式写入数据库以外，无法直接转为为字符串，因为字符串结尾有\0，当然肯定还有其他原因。

下面提供几种Java中使用的方案：

方案一：直接利用BigInteger的方法，应该是最简单的方案了。

[java] view plain copy print ?

1. /** 
2.      * 利用签名辅助类，将字符串字节数组 
3.      * @param str 
4.      * @return 
5.      */  
6.     public static byte[] md5(String str)  
7.     {  
8.         byte[] digest = null;  
9.         try  
10.         {  
11.             MessageDigest md = MessageDigest.getInstance("md5");  
12.             return digest = md.digest(str.getBytes());  
13.    
14.         } catch (NoSuchAlgorithmException e)  
15.         {  
16.             e.printStackTrace();  
17.         }  
18.         return null;  
19.     }  
20.     /** 
21.      * 方式一 
22.      *  
23.      * @param bytes 
24.      * @return 
25.      */  
26.     public static String bytes2hex01(byte[] bytes)  
27.     {  
28.         /** 
29.          * 第一个参数的解释，记得一定要设置为1 
30.          *  signum of the number (-1 for negative, 0 for zero, 1 for positive). 
31.          */  
32.         BigInteger bigInteger = new BigInteger(1, bytes);  
33.         return bigInteger.toString(16);  
34.     }  
35.       

/**
     * 利用签名辅助类，将字符串字节数组
     * @param str
     * @return
     */
    public static byte[] md5(String str)
    {
        byte[] digest = null;
        try
        {
            MessageDigest md = MessageDigest.getInstance("md5");
            return digest = md.digest(str.getBytes());
 
        } catch (NoSuchAlgorithmException e)
        {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 方式一
     * 
     * @param bytes
     * @return
     */
    public static String bytes2hex01(byte[] bytes)
    {
        /**
         * 第一个参数的解释，记得一定要设置为1
         *  signum of the number (-1 for negative, 0 for zero, 1 for positive).
         */
        BigInteger bigInteger = new BigInteger(1, bytes);
        return bigInteger.toString(16);
    }
    

 

方案二：将每个字节与0xFF进行与运算，然后转化为10进制，然后借助于Integer再转化为16进制

[java] view plain copy print ?

1. /** 
2.      * 方式二 
3.      *  
4.      * @param bytes 
5.      * @return 
6.      */  
7.     public static String bytes2hex02(byte[] bytes)  
8.     {  
9.         StringBuilder sb = new StringBuilder();  
10.         String tmp = null;  
11.         for (byte b : bytes)  
12.         {  
13.             // 将每个字节与0xFF进行与运算，然后转化为10进制，然后借助于Integer再转化为16进制  
14.             tmp = Integer.toHexString(0xFF & b);  
15.             if (tmp.length() == 1)// 每个字节8为，转为16进制标志，2个16进制位  
16.             {  
17.                 tmp = "0" + tmp;  
18.             }  
19.             sb.append(tmp);  
20.         }  
21.    
22.         return sb.toString();  
23.    
24.     }  

/**
     * 方式二
     * 
     * @param bytes
     * @return
     */
    public static String bytes2hex02(byte[] bytes)
    {
        StringBuilder sb = new StringBuilder();
        String tmp = null;
        for (byte b : bytes)
        {
            // 将每个字节与0xFF进行与运算，然后转化为10进制，然后借助于Integer再转化为16进制
            tmp = Integer.toHexString(0xFF & b);
            if (tmp.length() == 1)// 每个字节8为，转为16进制标志，2个16进制位
            {
                tmp = "0" + tmp;
            }
            sb.append(tmp);
        }
 
        return sb.toString();
 
    }

 

方案三：分别取出字节的高四位与低四位然后分别得出10进制0-15这样的值，再利用一个字符串数组完美完成。对于转化的理解，当然最推荐第三种方式了。

[java] view plain copy print ?

1. /** 
2.      * 方式三 
3.      *  
4.      * @param bytes 
5.      * @return 
6.      */  
7.     public static String bytes2hex03(byte[] bytes)  
8.     {  
9.         final String HEX = "0123456789abcdef";  
10.         StringBuilder sb = new StringBuilder(bytes.length * 2);  
11.         for (byte b : bytes)  
12.         {  
13.             // 取出这个字节的高4位，然后与0x0f与运算，得到一个0-15之间的数据，通过HEX.charAt(0-15)即为16进制数  
14.             sb.append(HEX.charAt((b >> 4) & 0x0f));  
15.             // 取出这个字节的低位，与0x0f与运算，得到一个0-15之间的数据，通过HEX.charAt(0-15)即为16进制数  
16.             sb.append(HEX.charAt(b & 0x0f));  
17.         }  
18.    
19.         return sb.toString();  
20.     }  

/**
     * 方式三
     * 
     * @param bytes
     * @return
     */
    public static String bytes2hex03(byte[] bytes)
    {
        final String HEX = "0123456789abcdef";
        StringBuilder sb = new StringBuilder(bytes.length * 2);
        for (byte b : bytes)
        {
            // 取出这个字节的高4位，然后与0x0f与运算，得到一个0-15之间的数据，通过HEX.charAt(0-15)即为16进制数
            sb.append(HEX.charAt((b >> 4) & 0x0f));
            // 取出这个字节的低位，与0x0f与运算，得到一个0-15之间的数据，通过HEX.charAt(0-15)即为16进制数
            sb.append(HEX.charAt(b & 0x0f));
        }
 
        return sb.toString();
    }