Java中byte与16进制字符串的转换

因工作上经常用到byte转换成16进制字符串、16进制字符串转换为byte等，故将相关知识整理一下：

 

Java中byte用二进制表示占用8位，而我们知道16进制的每个字符需要用4位二进制位来表示（23 + 22 + 21 + 20 = 15），所以我们就可以把每个byte转换成两个相应的16进制字符，即把byte的高4位和低4位分别转换成相应的16进制字符H和L，并组合起来得到byte转换到16进制字符串的结果new String(H) + new String(L)。即byte用十六进制表示只占2位。

同理，相反的转换也是将两个16进制字符转换成一个byte，原理同上。

根据以上原理，我们就可以将byte[] 数组转换为16进制字符串了，当然也可以将16进制字符串转换为byte[]数组了。

package com.ljf;

import java.util.Locale;

public class CHexConver {
	
	private final static char[] mChars = "0123456789ABCDEF".toCharArray();  
	private final static String mHexStr = "0123456789ABCDEF";  
	
    /**  
     * 检查16进制字符串是否有效 
     * @param sHex String 16进制字符串 
     * @return boolean 
     */    
    public static boolean checkHexStr(String sHex){    
        String sTmp = sHex.toString().trim().replace(" ", "").toUpperCase(Locale.US);  
        int iLen = sTmp.length();  
          
        if (iLen > 1 && iLen%2 == 0){  
            for(int i=0; i<iLen; i++)  
                if (!mHexStr.contains(sTmp.substring(i, i+1)))  
                    return false;  
            return true;  
        }  
        else  
            return false;  
    }  
    
    /**  
     * 字符串转换成十六进制字符串 
     * @param str String 待转换的ASCII字符串 
     * @return String 每个Byte之间空格分隔，如: [61 6C 6B] 
     */    
    public static String str2HexStr(String str){    
        StringBuilder sb = new StringBuilder();  
        byte[] bs = str.getBytes();    
          
        for (int i = 0; i < bs.length; i++){    
            sb.append(mChars[(bs[i] & 0xFF) >> 4]);    
            sb.append(mChars[bs[i] & 0x0F]);  
            sb.append(' ');  
        }    
        return sb.toString().trim();    
    }
    
    /**  
     * 十六进制字符串转换成 ASCII字符串 
     * @param str String Byte字符串 
     * @return String 对应的字符串 
     */    
    public static String hexStr2Str(String hexStr){    
        hexStr = hexStr.toString().trim().replace(" ", "").toUpperCase(Locale.US);  
        char[] hexs = hexStr.toCharArray();    
        byte[] bytes = new byte[hexStr.length() / 2];    
        int iTmp = 0x00;;    
  
        for (int i = 0; i < bytes.length; i++){    
            iTmp = mHexStr.indexOf(hexs[2 * i]) << 4;    
            iTmp |= mHexStr.indexOf(hexs[2 * i + 1]);    
            bytes[i] = (byte) (iTmp & 0xFF);    
        }    
        return new String(bytes);    
    }
    
    /** 
     * bytes字符串转换为Byte值 
     * @param src String Byte字符串，每个Byte之间没有分隔符(字符范围:0-9 A-F) 
     * @return byte[] 
     */  
    public static byte[] hexStr2Bytes(String src){  
        /*对输入值进行规范化整理*/  
        src = src.trim().replace(" ", "").toUpperCase(Locale.US);  
        //处理值初始化  
        int m=0,n=0;  
        int iLen=src.length()/2; //计算长度  
        byte[] ret = new byte[iLen]; //分配存储空间  
          
        for (int i = 0; i < iLen; i++){  
            m=i*2+1;  
            n=m+1;  
            ret[i] = (byte)(Integer.decode("0x"+ src.substring(i*2, m) + src.substring(m,n)) & 0xFF);  
        }  
        return ret;  
    } 

    /** 
     * String的字符串转换成unicode的String 
     * @param strText String 全角字符串 
     * @return String 每个unicode之间无分隔符 
     * @throws Exception 
     */  
    public static String strToUnicode(String strText)  
        throws Exception  
    {  
        char c;  
        StringBuilder str = new StringBuilder();  
        int intAsc;  
        String strHex;  
        for (int i = 0; i < strText.length(); i++){  
            c = strText.charAt(i);  
            intAsc = (int) c;  
            strHex = Integer.toHexString(intAsc);  
            if (intAsc > 128)  
                str.append("\\u");  
            else // 低位在前面补00  
                str.append("\\u00");  
            str.append(strHex);  
        }  
        return str.toString();  
    }
    
    /** 
     * unicode的String转换成String的字符串 
     * @param hex String 16进制值字符串 （一个unicode为2byte） 
     * @return String 全角字符串 
     * @see CHexConver.unicodeToString("\\u0068\\u0065\\u006c\\u006c\\u006f") 
     */  
    public static String unicodeToString(String hex){  
        int t = hex.length() / 6;  
        int iTmp = 0;  
        StringBuilder str = new StringBuilder();  
        for (int i = 0; i < t; i++){  
            String s = hex.substring(i * 6, (i + 1) * 6);  
            // 将16进制的string转为int  
            iTmp = (Integer.valueOf(s.substring(2, 4), 16) << 8) | Integer.valueOf(s.substring(4), 16);  
            // 将int转换为字符  
            str.append(new String(Character.toChars(iTmp)));  
        }  
        return str.toString();  
    }  
    
	/**
	 * Convert byte[] to hex string.这里我们可以将byte转换成int<br>
	 * 然后利用Integer.toHexString(int)来转换成16进制字符串。  
	 * @param src byte[] data  
	 * @return hex string  
	 */     
	public static String bytesToHexString(byte[] src){  
	    StringBuilder stringBuilder = new StringBuilder("");  
	    if (src == null || src.length <= 0) {  
	        return null;  
	    }  
	    for (int i = 0; i < src.length; i++) {  
	        int v = src[i] & 0xFF;  
	        String hv = Integer.toHexString(v);  
	        if (hv.length() < 2) {  
	            stringBuilder.append(0);  
	        }  
	        stringBuilder.append(hv);  
	    }  
	    return stringBuilder.toString();  
	} 
	/** 
	 * Convert hex string to byte[] 
	 * @param hexString the hex string 
	 * @return byte[] 
	 */  
	public static byte[] hexStringToBytes(String hexString) {  
	    if (hexString == null || hexString.equals("")) {  
	        return null;  
	    }  
	    hexString = hexString.toUpperCase();  
	    int length = hexString.length() / 2;  
	    char[] hexChars = hexString.toCharArray();  
	    byte[] d = new byte[length];  
	    for (int i = 0; i < length; i++) {  
	        int pos = i * 2;  
	        d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));  
	    }  
	    return d;  
	} 
	
	/**
	 * 将指定byte数组以16进制的形式打印到控制台  
	 * @param b
	 */
	public static void printHexString( byte[] b) {    
	   for (int i = 0; i < b.length; i++) {   
	     String hex = Integer.toHexString(b[i] & 0xFF);   
	     if (hex.length() == 1) {   
	       hex = '0' + hex;   
	     }   
	     System.out.print(hex.toUpperCase() );   
	   }   
	  
	}
	
	/** 
	 * Convert char to byte 
	 * @param c char 
	 * @return byte 
	 */  
	 private static byte charToByte(char c) {  
	    return (byte) "0123456789ABCDEF".indexOf(c);  
	} 

}