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[]數組了。
publicstaticString bytesToHexString(byte[] src){
StringBuilder stringBuilder =newStringBuilder("");
if(src ==null|| src.length <=0) {
returnnull;
}
for(inti =0; i
intv = src[i] &0xFF;
String hv = Integer.toHexString(v);
if(hv.length() <2) {
stringBuilder.append(0);
}
stringBuilder.append(hv);
}
returnstringBuilder.toString();
}
publicstaticbyte[] hexStringToBytes(String hexString) {
if(hexString ==null|| hexString.equals("")) {
returnnull;
}
hexString = hexString.toUpperCase();
intlength = hexString.length() /2;
char[] hexChars = hexString.toCharArray();
byte[] d =newbyte[length];
for(inti =0; i
intpos = i *2;
d[i] = (byte) (charToByte(hexChars[pos]) <<4| charToByte(hexChars[pos +1]));
}
returnd;
}
privatebytecharToByte(charc) {
return(byte)"0123456789ABCDEF".indexOf(c);
}
* 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();
}
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;
}
private byte charToByte(char c) {
return (byte) "0123456789ABCDEF".indexOf(c);
}
Java代碼
//将指定byte數組以16進制的形式列印到控制台
publicstaticvoidprintHexString(byte[] b) {
for(inti =0; i
String hex = Integer.toHexString(b[i] &0xFF);
if(hex.length() ==1) {
hex ='0'+ hex;
}
System.out.print(hex.toUpperCase() );
}
}
//将指定byte數組以16進制的形式列印到控制台
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() );
}
}
java中byte轉換int時為何與0xff進行與運算
在剖析該問題前請看如下代碼
Java代碼
publicstaticString bytes2HexString(byte[] b) {
String ret ="";
for(inti =0; i
String hex = Integer.toHexString(b[ i ] &0xFF);
if(hex.length() ==1) {
hex ='0'+ hex;
}
ret += hex.toUpperCase();
}
returnret;
}
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，于是結果總是我們想要的。