[轉]Java中byte與16進制字符串的互相轉換

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[]數組了。

* Convert byte[] to hex string.這里我們可以將byte轉換成int，然后利用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;  
}  
/** 
 * Convert char to byte 
 * @param c char 
 * @return byte 
 */  
 private byte charToByte(char c) {  
    return (byte) "0123456789ABCDEF".indexOf(c);  
}  

java中byte轉換int時為何與0xff進行與運算

在剖析該問題前請看如下代碼

public static String bytes2HexString(byte[] b) {
  String ret = "";
  for (int i = 0; i < b.length; i++) {
   String hex = Integer.toHexString(b[ i ] & 0xFF);
   if (hex.length() == 1) {
    hex = '0' + hex;
   }
   ret += hex.toUpperCase();
  }
  return ret;
}

上面是將byte[]轉化十六進制的字符串,注意這里b[ i ] & 0xFF將一個byte和 0xFF進行了與運算,然后使用Integer.toHexString取得了十六進制字符串,可以看出
b[ i ] & 0xFF運算后得出的仍然是個int,那么為何要和 0xFF進行與運算呢?直接 Integer.toHexString(b[ i ]);,將byte強轉為int不行嗎?答案是不行的.

其原因在於:
1.byte的大小為8bits而int的大小為32bits
2.java的二進制采用的是補碼形式

==================以下文字貌似有問題===================
在這里先溫習下計算機基礎理論

byte是一個字節保存的，有8個位，即8個0、1。
8位的第一個位是符號位， 
也就是說0000 0001代表的是數字1 
1000 0000代表的就是-1 
所以正數最大位0111 1111，也就是數字127 
負數最大為1111 1111，也就是數字-128

上面說的是二進制原碼，但是在java中采用的是補碼的形式，下面介紹下什么是補碼

1、反碼：
        一個數如果是正，則它的反碼與原碼相同；
        一個數如果是負，則符號位為1，其余各位是對原碼取反；

2、補碼：利用溢出，我們可以將減法變成加法
       對於十進制數，從9得到5可用減法：
       9－4＝5    因為4+6＝10，我們可以將6作為4的補數
       改寫為加法：
       9+6＝15（去掉高位1，也就是減10）得到5.

       對於十六進制數，從c到5可用減法：
       c－7＝5    因為7+9＝16 將9作為7的補數
       改寫為加法：
       c+9＝15（去掉高位1，也就是減16）得到5.

    在計算機中，如果我們用1個字節表示一個數，一個字節有8位，超過8位就進1，在內存中情況為（100000000），進位1被丟棄。

    ⑴一個數為正，則它的原碼、反碼、補碼相同
    ⑵一個數為負，剛符號位為1，其余各位是對原碼取反，然后整個數加1
    
- 1的原碼為                10000001
- 1的反碼為                11111110
                                                   + 1
- 1的補碼為                11111111

0的原碼為                 00000000
0的反碼為                 11111111（正零和負零的反碼相同）
                                          +1
0的補碼為               100000000（舍掉打頭的1，正零和負零的補碼相同）

Integer.toHexString的參數是int，如果不進行&0xff，那么當一個byte會轉換成int時，由於int是32位，而byte只有8位這時會進行補位，
例如補碼11111111的十進制數為-1轉換為int時變為11111111111111111111111111111111好多1啊，呵呵！即0xffffffff但是這個數是不對的，這種補位就會造成誤差。
和0xff相與后，高24比特就會被清0了，結果就對了。

----
Java中的一個byte，其范圍是-128~127的，而Integer.toHexString的參數本來是int，如果不進行&0xff，那么當一個byte會轉換成int時，對於負數，會做位擴展，舉例來說，一個byte的-1（即0xff），會被轉換成int的-1（即0xffffffff），那么轉化出的結果就不是我們想要的了。

而0xff默認是整形，所以，一個byte跟0xff相與會先將那個byte轉化成整形運算，這樣，結果中的高的24個比特就總會被清0，於是結果總是我們想要的。

轉載自http://blog.csdn.net/androiddeveloper_lee/article/details/6619414

轉載自http://www.blogjava.net/orangelizq/archive/2008/07/20/216228.html