java二进制,字节数组,字符,十六进制,BCD编码转换

转载：http://blog.csdn.net/ycb1689/article/details/22922889

java二进制,字节数组,字符,十六进制,BCD编码转换

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[]数组了。 

[java]  view plain  copy

1.    /* 
2.     * 把16进制字符串转换成字节数组 
3.     * @param hex 
4.     * @return 
5.     */  
6. public static byte[] hexStringToByte(String hex) {  
7.     int len = (hex.length() / 2); //除以2是因为十六进制比如a1使用两个字符代表一个byte  
8.     byte[] result = new byte[len];  
9.     char[] achar = hex.toCharArray();  
10.     for (int i = 0; i < len; i++) {  
11.     //乘以2是因为十六进制比如a1使用两个字符代表一个byte,pos代表的是数组的位置  
12.      //第一个16进制数的起始位置是0第二个是2以此类推   
13.  int pos = i * 2;   
14.    
15.      //<<4位就是乘以16  比如说十六进制的"11",在这里也就是1*16|1,而其中的"|"或运算就相当于十进制中的加法运算   
16.     //如00010000|00000001结果就是00010001 而00010000就有点类似于十进制中10而00000001相当于十进制中的1，与是其中的或运算就相当于是10+1(此处说法可能不太对，)  
17.      result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));  
18.     }  
19.     return result;  
20. }  
21.    
22. private static byte toByte(char c) {  
23.     byte b = (byte) "0123456789ABCDEF".indexOf(c);  
24.     return b;  
25. }  
26.    
27. /** 
28.     * 把字节数组转换成16进制字符串 
29.     * @param bArray 
30.     * @return 
31.     */  
32. public static final String bytesToHexString(byte[] bArray) {  
33.     StringBuffer sb = new StringBuffer(bArray.length);  
34.     String sTemp;  
35.     for (int i = 0; i < bArray.length; i++) {  
36.      sTemp = Integer.toHexString(0xFF & bArray[i]);  
37.      if (sTemp.length() < 2)  
38.       sb.append(0);  
39.      sb.append(sTemp.toUpperCase());  
40.     }  
41.     return sb.toString();  
42. }  
43.    
44. /** 
45.     * 把字节数组转换为对象 
46.     * @param bytes 
47.     * @return 
48.     * @throws IOException 
49.     * @throws ClassNotFoundException 
50.     */  
51. public static final Object bytesToObject(byte[] bytes) throws IOException, ClassNotFoundException {  
52.     ByteArrayInputStream in = new ByteArrayInputStream(bytes);  
53.     ObjectInputStream oi = new ObjectInputStream(in);  
54.     Object o = oi.readObject();  
55.     oi.close();  
56.     return o;  
57. }  
58.    
59. /** 
60.     * 把可序列化对象转换成字节数组 
61.     * @param s 
62.     * @return 
63.     * @throws IOException 
64.     */  
65. public static final byte[] objectToBytes(Serializable s) throws IOException {  
66.     ByteArrayOutputStream out = new ByteArrayOutputStream();  
67.     ObjectOutputStream ot = new ObjectOutputStream(out);  
68.     ot.writeObject(s);  
69.     ot.flush();  
70.     ot.close();  
71.     return out.toByteArray();  
72. }  
73.    
74. public static final String objectToHexString(Serializable s) throws IOException{  
75.     return bytesToHexString(objectToBytes(s));  
76. }  
77.    
78. public static final Object hexStringToObject(String hex) throws IOException, ClassNotFoundException{  
79.     return bytesToObject(hexStringToByte(hex));  
80. }  
81.    
82. /** *//** 
83.     * @函数功能: BCD码转为10进制串(阿拉伯数据) 
84.     * @输入参数: BCD码 
85.     * @输出结果: 10进制串 
86.     */  
87. public static String bcd2Str(byte[] bytes){  
88.     StringBuffer temp=new StringBuffer(bytes.length*2);  
89.    
90.     for(int i=0;i<bytes.length;i++){  
91.      temp.append((byte)((bytes[i]& 0xf0)>>>4));  
92.      temp.append((byte)(bytes[i]& 0x0f));  
93.     }  
94.     return temp.toString().substring(0,1).equalsIgnoreCase("0")?temp.toString().substring(1):temp.toString();  
95. }  
96.    
97. /** 
98.     * @函数功能: 10进制串转为BCD码 
99.     * @输入参数: 10进制串 
100.     * @输出结果: BCD码 
101.     */  
102. public static byte[] str2Bcd(String asc) {  
103.     int len = asc.length();  
104.     int mod = len % 2;  
105.    
106.     if (mod != 0) {  
107.      asc = "0" + asc;  
108.      len = asc.length();  
109.     }  
110.    
111.     byte abt[] = new byte[len];  
112.     if (len >= 2) {  
113.      len = len / 2;  
114.     }  
115.    
116.     byte bbt[] = new byte[len];  
117.     abt = asc.getBytes();  
118.     int j, k;  
119.    
120.     for (int p = 0; p < asc.length()/2; p++) {  
121.      if ( (abt[2 * p] >= '0') && (abt[2 * p] <= '9')) {  
122.       j = abt[2 * p] - '0';  
123.      } else if ( (abt[2 * p] >= 'a') && (abt[2 * p] <= 'z')) {  
124.       j = abt[2 * p] - 'a' + 0x0a;  
125.      } else {  
126.       j = abt[2 * p] - 'A' + 0x0a;  
127.      }  
128.    
129.      if ( (abt[2 * p + 1] >= '0') && (abt[2 * p + 1] <= '9')) {  
130.       k = abt[2 * p + 1] - '0';  
131.      } else if ( (abt[2 * p + 1] >= 'a') && (abt[2 * p + 1] <= 'z')) {  
132.       k = abt[2 * p + 1] - 'a' + 0x0a;  
133.      }else {  
134.       k = abt[2 * p + 1] - 'A' + 0x0a;  
135.      }  
136.    
137.      int a = (j << 4) + k;  
138.      byte b = (byte) a;  
139.      bbt[p] = b;  
140.     }  
141.     return bbt;  
142. }  
143. /** 
144.     * @函数功能: BCD码转ASC码 
145.     * @输入参数: BCD串 
146.     * @输出结果: ASC码 
147.     */  
148. public static String BCD2ASC(byte[] bytes) {  
149.     StringBuffer temp = new StringBuffer(bytes.length * 2);  
150.    
151.     for (int i = 0; i < bytes.length; i++) {  
152.      int h = ((bytes[i] & 0xf0) >>> 4);  
153.      int l = (bytes[i] & 0x0f);     
154.      temp.append(BToA[h]).append( BToA[l]);  
155.     }  
156.     return temp.toString() ;  
157. }  
158.    
159. /** 
160.     * MD5加密字符串，返回加密后的16进制字符串 
161.     * @param origin 
162.     * @return 
163.     */  
164. public static String MD5EncodeToHex(String origin) {   
165.        return bytesToHexString(MD5Encode(origin));  
166.      }  
167.    
168. /** 
169.     * MD5加密字符串，返回加密后的字节数组 
170.     * @param origin 
171.     * @return 
172.     */  
173. public static byte[] MD5Encode(String origin){  
174.     return MD5Encode(origin.getBytes());  
175. }  
176.    
177. /** 
178.     * MD5加密字节数组，返回加密后的字节数组 
179.     * @param bytes 
180.     * @return 
181.     */  
182. public static byte[] MD5Encode(byte[] bytes){  
183.     MessageDigest md=null;  
184.     try {  
185.      md = MessageDigest.getInstance("MD5");  
186.      return md.digest(bytes);  
187.     } catch (NoSuchAlgorithmException e) {  
188.      e.printStackTrace();  
189.      return new byte[0];  
190.     }  
191.   
192. }  

//关于byte: signed byte 把 0x00 ~ 0xff 映射成范围 0~127和 -128~-1 两段,比较简单的办法用 (b+256)%256的办法令其值回到0~255，或者用&0xff并赋给一个int。

java中byte转换int时为何与0xff进行与运算

在剖析该问题前请看如下代码 

[java]  view plain  copy

1. public static String bytes2HexString(byte[] b) {  
2.   String ret = "";  
3.   for (int i = 0; i < b.length; i++) {  
4.    String hex = Integer.toHexString(b[ i ] & 0xFF);  
5.    if (hex.length() == 1) {  
6.     hex = '0' + hex;  
7.    }  
8.    ret += hex.toUpperCase();  
9.   }  
10.   return ret;  
11. }  

上面是将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，于是结果总是我们想要的。