二进制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();
}