Java中String字符串转换十六进制Hex类型
今天我们说一下Java中 String字符串转换为Hex十六进制字符串、byte[]字节数组转换Hex十六进制字符串。
好，接下来代码走起来-------->

1、字符串转换为十六进制字符串
public static String stringToHexString(String s) {  
            String str = "";  
            for (int i = 0; i < s.length(); i++) {  
                int ch = s.charAt(i);  
                String s4 = Integer.toHexString(ch);  
                str = str + s4;  
            }  
            return str;  
} 

2、十六进制字符串转换为字符串
public static String hexStringToString(String s) {  
            if (s == null || s.equals("")) {  
                return null;  
            }  
            s = s.replace(" ", "");  
            byte[] baKeyword = new byte[s.length() / 2];  
            for (int i = 0; i < baKeyword.length; i++) {  
                try {  
                    baKeyword[i] = (byte) (0xff & Integer.parseInt(  
                            s.substring(i * 2, i * 2 + 2), 16));  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
            }  
            try {  
                s = new String(baKeyword, "gbk");  
                new String();  
            } catch (Exception e1) {  
                e1.printStackTrace();  
            }  
            return s;  
}

3、十六进制字符串转换为byte[]数组
public static byte[] hexStringToByteArray(String s) {
          int len = s.length();
          byte[] b = new byte[len / 2];
          for (int i = 0; i < len; i += 2) {
              // 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个字节
              b[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character
                      .digit(s.charAt(i + 1), 16));
          }
          return b;
}

4、byte[]字节数组转十六进制字符串
public static final String bytesToHexString(byte[] bArray) {
          StringBuffer sb = new StringBuffer(bArray.length);
          String sTemp;
          for (int i = 0; i < bArray.length; i++) {
           sTemp = Integer.toHexString(0xFF & bArray[i]);
           if (sTemp.length() < 2)
            sb.append(0);
           sb.append(sTemp.toUpperCase());
          }
          return sb.toString();
}

一、十进制数字转化为无符号的2进制字符串

String Binary = Integer.toBinaryString(88);  
二、进制字符串转化为十进制数字


Integer Decimal = Integer.valueOf("10001000", 2);

三、十六进制字符串转化为十进制数字


String hexString = Integer.toHexString(136);
四、十进制转化为十六进制字符串 


long parseLong = Long.parseLong("88", 16);
Integer Hex= Integer.valueOf("88", 16);  //两种方法都可以

五、byte转化为二进制也就是转化为bit


/** 
 * Byte转二进制 
 */  
public static String byteToBit(byte b) {  
    return "" +(byte)((b >> 7) & 0x1) +   
    (byte)((b >> 6) & 0x1) +   
    (byte)((b >> 5) & 0x1) +   
    (byte)((b >> 4) & 0x1) +   
    (byte)((b >> 3) & 0x1) +   
    (byte)((b >> 2) & 0x1) +   
    (byte)((b >> 1) & 0x1) +   
    (byte)((b >> 0) & 0x1);  
}
六、bits转化为byte

	/**
	 * bits转化为byte
	 * 
	 * @param bits
	 *            00100100,0101,00101111,11
	 * @return
	 */
	public static byte[] byte2String(String bits) {
		// 假设bits 是01，10，011，00以，分隔的格式的字符串
		String[] bitsStr = bits.split(",");
		byte[] byteArray = new byte[bitsStr.length];
		for (int i = 0; i < byteArray.length; i++) {
			byteArray[i] = (byte) parse(bitsStr[i]);
		}
		return byteArray;
	}

	public static int parse(String str) {
		// 32位 为负数
		if (32 == str.length()) {
			str = "-" + str.substring(1);
			return -(Integer.parseInt(str, 2) + Integer.MAX_VALUE + 1);
		}
		return Integer.parseInt(str, 2);
	}
或：
    public static char bitsToHex(int bit) {
        if(bit >= 0 && bit <= 9) {
            return (char)((int)'0'+bit);
        } else if(bit >= 10 && bit <= 15) {
            return (char)((int)'A'+bit-10);
        }
        return '-';
    }

    public static String bytesToHex(byte[] bs) {
        if(bs == null)
            return "null";

        StringBuilder sb = new StringBuilder();
        for(byte b : bs ) {
            sb.append(bitsToHex((b>>4)&0x0F));
            sb.append(bitsToHex(b&0x0F));
            sb.append(" ");
        }
        return sb.toString();
    }


七、byte转化为十六进制

    /**
     * @param b 字节数组
     * @return 16进制字符串
     * @desc 将字节数组转换为16进制字符串
     */
    public static String Bytes2Hex(byte[] b)
    {
        String hexStr = "";
        for (int i = 0; i < b.length; i++)
        {
            String hex = Integer.toHexString(b[i] & 0xFF);
            if (hex.length() == 1)
            {
                hex = '0' + hex;
            }
            hexStr += hex.toUpperCase();
        }
        return hexStr;
    }
也可以这样专转化：


    /**
     * 字节数组转化为十六进制字符串
     * @param bs  字节数组
     * @return  字符串
     */
    public static String bytesToHex(byte[] bs) {
        if(bs == null)
            return "null";

        StringBuilder sb = new StringBuilder();
        for(byte b : bs ) {
            sb.append(bitsToHex((b>>4)&0x0F));
            sb.append(bitsToHex(b&0x0F));
            sb.append(" ");
        }
        return sb.toString();
    }
    
	/**
	 * bit转化为ASCII中的字符串
	 * @param bit
	 * @return
	 */
    public static char bitsToHex(int bit) {
        if(bit >= 0 && bit <= 9) {
            return (char)((int)'0'+bit);
        } else if(bit >= 10 && bit <= 15) {
            return (char)((int)'A'+bit-10);
        }
        return '-';
    }
八、 十六进制字符串转化为字节数组


	/**
	 * 十六进制字符串转化为字节数组
	 * @param str
	 * @param maxSize
	 * @return
	 * @throws Throwable
	 */
	 public static byte[] bytesFromHex(String str, int maxSize) throws Throwable {
	        ByteBuffer bb = ByteBuffer.allocate(maxSize);
	        // fix : order bug
	        bb.order(ByteOrder.LITTLE_ENDIAN);

	        char[] src = str.toCharArray();
	        //mLogger.addLog(Utils.bytesToHex(src));

	        for(int i=0; i<src.length; i++) {
	            if(src[i] == 0x20)
	                continue;
	            if(i+1 < src.length) {
	                int hi = valueFromHex(src[i]);
	                int lo = valueFromHex(src[i+1]);
	                bb.put((byte) (hi*16+lo));
	                i++;
	            } else {
	                throw new Exception("failed to convert hex string.");
	            }
	        }

	        if(bb.hasArray())
	            return bb.array();
	        return null;
	    }
	 
	   public static int valueFromHex(char hex) throws Exception {
	        if(hex >= '0' && hex <= '9')
	            return (int) (hex-'0');
	        if(hex >= 'a' && hex <= 'f')
	            return (int) (hex-'a'+10);
	        if(hex >= 'A' && hex <= 'F')
	            return (int) (hex-'A'+10);
	        throw new Exception("failed to convert hex.");
	    }
九、十六进制字符串转化为二进制字符串


  /**
     * 十六进制转化为二进制
     * @param hexString  十六进制数据源
     * @return  二进制数
     */
    public static String hexString2binaryString(String hexString)
    {
        if (hexString == null || hexString.length() % 2 != 0)
            return null;
        String bString = "", tmp;
        for (int i = 0; i < hexString.length(); i++)
        {
            tmp = "0000"
                    + Integer.toBinaryString(Integer.parseInt(hexString
                    .substring(i, i + 1), 16));
            bString += tmp.substring(tmp.length() - 4);
        }
        return bString;
    }
十、二进制字符串转化为十六进制字符串
    /**
     * 二进制数转化为十六进制
     * @param bString  十六进制数
     * @return  十六进制数
     */
    public static String binaryString2hexString(String bString)
    {
        if (bString == null || bString.equals("") || bString.length() % 8 != 0)
            return null;
        StringBuffer tmp = new StringBuffer();
        int iTmp = 0;
        for (int i = 0; i < bString.length(); i += 4)
        {
            iTmp = 0;
            for (int j = 0; j < 4; j++)
            {
                iTmp += Integer.parseInt(bString.substring(i + j, i + j + 1)) << (4 - j - 1);
            }
            tmp.append(Integer.toHexString(iTmp));
        }
        return tmp.toString();
    }

1.计算 hex 文件大小

unsigned long calculate_file_size(FILE *pFile){

    unsigned long fsize;

    fseek(pFile, 0, SEEK_END);
    fsize=ftell(pFile);
    fseek(pFile, 0, SEEK_SET);
    fsize = fsize/2; //两个字符一个字节

    return fsize;
}

2.将 hex 文件转换成 byte 数组

void Hex_to_ByteArray(FILE *pFile,char *buffer){

    unsigned long i=0;
    char ch[3];

    while( fgets(ch, 3, pFile) != NULL ) {

        int val = strtol(ch, NULL, 16);
        buffer[i++] = val;

    }
}

3.生成 byte 数组 

void ByteArray(FILE *pPile, unsigned long fsize){

    char buffer[fsize];
    Hex_to_ByteArray(pPile,buffer);

}

4.打开文件调用函数

#include <cstdio>
#include <fcntl.h>
#include <cstdlib>
#include <unistd.h>

void main(){

    unsigned long fsize;
    FILE *pFile = NULL;

    pFile = fopen("/路径/file.hex", "r");
    if(pFile == NULL) printf("Can not open file");
    fsize = calculate_file_size(pFile);
    ByteArray(pPile, fsize);

}

 

1.安装plugin

并不是到这里下载并拷贝到plugin文件夹里，不是这么用的。而是点击NotePad++的下拉菜单“Plugin”->  打开“Plugin Admin...” -> 选中“Hex Editor”  ->  单击“Install”

 

2使用：

先用notepad++打开二进制文件，然后再在plugin菜单里找到  Hex Editor -> view in Hex即可。

效果：