二进制Binary、十进制Decimal、十六进制Hex、字节byte，位bit的转化

一、十进制数字转化为无符号的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();
    }