Java中byte数组与short,int,char,long,float,double之间的转换

http://blog.csdn.net/top_code/article/details/20126575

某些场景下我们接受和发送的数据都是byte数组，例如在socket传输中，发送、者接收的数据都是 byte数组，或者是自定义传输协议或者文件格式中，为了保证数据安全、节省流量服务端需要对数据进行先加密、压缩，然后再进行传输；客户端对传输过来的数据进行解压缩、解密。而实际中我们会传输各种类型的数据，比如int，long，short间等等。
这就需要我们在使用中完成byte类型和short，int，long，float之间的转换。转换的核心在于其他类型的数据每位所占的转换后所占的byte不同。

首先说一下用的最多的byte[]和int之间的转换

[java] view plain copy

1. /** 
2.      * 将32位的int值放到4字节的byte[]里 
3.      *  
4.      * @param num 
5.      * @return 
6.      */  
7.     public static byte[] int2byteArray(int num) {  
8.         byte[] result = new byte[4];  
9.         result[0] = (byte) (num >>> 24);// 取最高8位放到0下标  
10.         result[1] = (byte) (num >>> 16);// 取次高8为放到1下标  
11.         result[2] = (byte) (num >>> 8); // 取次低8位放到2下标  
12.         result[3] = (byte) (num); // 取最低8位放到3下标  
13.         return result;  
14.     }  
15.   
16.     /** 
17.      * 将4字节的byte数组转成一个int值 
18.      *  
19.      * @param b 
20.      * @return 
21.      */  
22.     public static int byteArray2int(byte[] b) {  
23.         byte[] a = new byte[4];  
24.         int i = a.length - 1, j = b.length - 1;  
25.         for (; i >= 0; i--, j--) {// 从b的尾部(即int值的低位)开始copy数据  
26.             if (j >= 0)  
27.                 a[i] = b[j];  
28.             else  
29.                 a[i] = 0;// 如果b.length不足4,则将高位补0  
30.         }  
31.         int v0 = (a[0] & 0xff) << 24;// &0xff将byte值无差异转成int,避免Java自动类型提升后,会保留高位的符号位  
32.         int v1 = (a[1] & 0xff) << 16;  
33.         int v2 = (a[2] & 0xff) << 8;  
34.         int v3 = (a[3] & 0xff);  
35.         return v0 + v1 + v2 + v3;  
36.     }  

byte[]和short的互转

[java] view plain copy

1. /** 
2.      * 转换short为byte 
3.      *  
4.      * @param b 
5.      * @param s 
6.      *            需要转换的short 
7.      * @param index 
8.      *            第几位开始存放 
9.      */  
10.     public static void short2byteArray(byte b[], short s, int index) {  
11.         b[index + 1] = (byte) (s >> 8);  
12.         b[index + 0] = (byte) (s >> 0);  
13.     }  
14.   
15.     /** 
16.      * 通过byte数组取到short 
17.      *  
18.      * @param b 
19.      * @param index 
20.      *            第几位开始取 
21.      * @return 
22.      */  
23.     public static short byteArray2short(byte[] b, int index) {  
24.         return (short) (((b[index + 1] << 8) | b[index + 0] & 0xff));  
25.     }  

byte[]和char的互转

[java] view plain copy

1. /** 
2.      * 字符到字节转换 
3.      *  
4.      * @param ch 
5.      * @return 
6.      */  
7.     public static void char2byteArray(byte[] bb, char ch, int index) {  
8.         int temp = (int) ch;  
9.         // byte[] b = new byte[2];  
10.         for (int i = 0; i < 2; i++) {  
11.             // 将最高位保存在最低位  
12.             bb[index + i] = new Integer(temp & 0xff).byteValue();  
13.             temp = temp >> 8; // 向右移8位  
14.         }  
15.     }  
16.   
17.     /** 
18.      * 字节到字符转换 
19.      *  
20.      * @param b 
21.      * @return 
22.      */  
23.     public static char byteArray2char(byte[] b, int index) {  
24.         int s = 0;  
25.         if (b[index + 1] > 0)  
26.             s += b[index + 1];  
27.         else  
28.             s += 256 + b[index + 0];  
29.         s *= 256;  
30.         if (b[index + 0] > 0)  
31.             s += b[index + 1];  
32.         else  
33.             s += 256 + b[index + 0];  
34.         char ch = (char) s;  
35.         return ch;  
36.     }  

byte[]和float的互转

[java] view plain copy

1. /** 
2.      * float转换byte 
3.      * 
4.      * @param bb 
5.      * @param x 
6.      * @param index 
7.      */  
8.     public static void float2byteArray(byte[] bb, float x, int index) {  
9.         // byte[] b = new byte[4];  
10.         int l = Float.floatToIntBits(x);  
11.         for (int i = 0; i < 4; i++) {  
12.             bb[index + i] = new Integer(l).byteValue();  
13.             l = l >> 8;  
14.         }  
15.     }  
16.   
17.     /** 
18.      * 通过byte数组取得float 
19.      * 
20.      * @param bb 
21.      * @param index 
22.      * @return 
23.      */  
24.     public static float byteArray2float(byte[] b, int index) {  
25.         int l;  
26.         l = b[index + 0];  
27.         l &= 0xff;  
28.         l |= ((long) b[index + 1] << 8);  
29.         l &= 0xffff;  
30.         l |= ((long) b[index + 2] << 16);  
31.         l &= 0xffffff;  
32.         l |= ((long) b[index + 3] << 24);  
33.         return Float.intBitsToFloat(l);  
34.     }  

byte[]和double的互转

[java] view plain copy

1. /** 
2.      * double转换byte 
3.      * 
4.      * @param bb 
5.      * @param x 
6.      * @param index 
7.      */  
8.     public static void double2byteArray(byte[] bb, double x, int index) {  
9.         // byte[] b = new byte[8];  
10.         long l = Double.doubleToLongBits(x);  
11.         for (int i = 0; i < 4; i++) {  
12.             bb[index + i] = new Long(l).byteValue();  
13.             l = l >> 8;  
14.         }  
15.     }  
16.   
17.     /** 
18.      * 通过byte数组取得double 
19.      * 
20.      * @param bb 
21.      * @param index 
22.      * @return 
23.      */  
24.     public static double byteArray2double(byte[] b, int index) {  
25.         long l;  
26.         l = b[0];  
27.         l &= 0xff;  
28.         l |= ((long) b[1] << 8);  
29.         l &= 0xffff;  
30.         l |= ((long) b[2] << 16);  
31.         l &= 0xffffff;  
32.         l |= ((long) b[3] << 24);  
33.         l &= 0xffffffffl;  
34.         l |= ((long) b[4] << 32);  
35.         l &= 0xffffffffffl;  
36.         l |= ((long) b[5] << 40);  
37.         l &= 0xffffffffffffl;  
38.         l |= ((long) b[6] << 48);  
39.         l &= 0xffffffffffffffl;  
40.         l |= ((long) b[7] << 56);  
41.         return Double.longBitsToDouble(l);  
42.     }  

byte[]和long相互转换

[java] view plain copy

1. /** 
2.      * 将64位的long值放到8字节的byte数组 
3.      * @param num 
4.      * @return 返回转换后的byte数组 
5.      */  
6.     public static byte[] longTobyteArray(long num) {  
7.         byte[] result = new byte[8];  
8.         result[0] = (byte) (num >>> 56);// 取最高8位放到0下标  
9.         result[1] = (byte) (num >>> 48);// 取最高8位放到0下标  
10.         result[2] = (byte) (num >>> 40);// 取最高8位放到0下标  
11.         result[3] = (byte) (num >>> 32);// 取最高8位放到0下标  
12.         result[4] = (byte) (num >>> 24);// 取最高8位放到0下标  
13.         result[5] = (byte) (num >>> 16);// 取次高8为放到1下标  
14.         result[6] = (byte) (num >>> 8); // 取次低8位放到2下标  
15.         result[7] = (byte) (num); // 取最低8位放到3下标  
16.         return result;  
17.     }  
18.   
19.     /** 
20.      * 将8字节的byte数组转成一个long值 
21.      * @param byteArray 
22.      * @return 转换后的long型数值 
23.      */  
24.     public static long byteArrayTolong(byte[] byteArray) {  
25.         byte[] a = new byte[8];  
26.         int i = a.length - 1, j = byteArray.length - 1;  
27.         for (; i >= 0; i--, j--) {// 从b的尾部(即int值的低位)开始copy数据  
28.             if (j >= 0)  
29.                 a[i] = byteArray[j];  
30.             else  
31.                 a[i] = 0;// 如果b.length不足4,则将高位补0  
32.         }  
33.         // 注意此处和byte数组转换成int的区别在于，下面的转换中要将先将数组中的元素转换成long型再做移位操作，  
34.         // 若直接做位移操作将得不到正确结果，因为Java默认操作数字时，若不加声明会将数字作为int型来对待，此处必须注意。  
35.         long v0 = (long) (a[0] & 0xff) << 56;// &0xff将byte值无差异转成int,避免Java自动类型提升后,会保留高位的符号位  
36.         long v1 = (long) (a[1] & 0xff) << 48;  
37.         long v2 = (long) (a[2] & 0xff) << 40;  
38.         long v3 = (long) (a[3] & 0xff) << 32;  
39.         long v4 = (long) (a[4] & 0xff) << 24;  
40.         long v5 = (long) (a[5] & 0xff) << 16;  
41.         long v6 = (long) (a[6] & 0xff) << 8;  
42.         long v7 = (long) (a[7] & 0xff);  
43.         return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7;  
44.     }  

稍微注意一下就能发现，各种类型与byte之间的转换主要是位数的差异，在转换过程中涉及到的算法也是移位，只要你理解了这个过程，那么数据传输过程涉及到byte和其他类型数据的转换就很简单了

最后是完成的代码

[java] view plain copy

1. package com.algorithm.example;  
2.   
3. public class BytesUtil {  
4.   
5.     /** 
6.      * @param args 
7.      */  
8.     public static void main(String[] args) {  
9.         // TODO Auto-generated method stub  
10.   
11.     }  
12.   
13.     /** 
14.      * 将32位的int值放到4字节的byte[]里 
15.      *  
16.      * @param num 
17.      * @return 
18.      */  
19.     public static byte[] int2byteArray(int num) {  
20.         byte[] result = new byte[4];  
21.         result[0] = (byte) (num >>> 24);// 取最高8位放到0下标  
22.         result[1] = (byte) (num >>> 16);// 取次高8为放到1下标  
23.         result[2] = (byte) (num >>> 8); // 取次低8位放到2下标  
24.         result[3] = (byte) (num); // 取最低8位放到3下标  
25.         return result;  
26.     }  
27.   
28.     /** 
29.      * 将4字节的byte数组转成一个int值 
30.      *  
31.      * @param b 
32.      * @return 
33.      */  
34.     public static int byteArray2int(byte[] b) {  
35.         byte[] a = new byte[4];  
36.         int i = a.length - 1, j = b.length - 1;  
37.         for (; i >= 0; i--, j--) {// 从b的尾部(即int值的低位)开始copy数据  
38.             if (j >= 0)  
39.                 a[i] = b[j];  
40.             else  
41.                 a[i] = 0;// 如果b.length不足4,则将高位补0  
42.         }  
43.         int v0 = (a[0] & 0xff) << 24;// &0xff将byte值无差异转成int,避免Java自动类型提升后,会保留高位的符号位  
44.         int v1 = (a[1] & 0xff) << 16;  
45.         int v2 = (a[2] & 0xff) << 8;  
46.         int v3 = (a[3] & 0xff);  
47.         return v0 + v1 + v2 + v3;  
48.     }  
49.   
50.     /** 
51.      * 转换short为byte 
52.      *  
53.      * @param b 
54.      * @param s 
55.      *            需要转换的short 
56.      * @param index 
57.      *            第几位开始存放 
58.      */  
59.     public static void short2byteArray(byte b[], short s, int index) {  
60.         b[index + 1] = (byte) (s >> 8);  
61.         b[index + 0] = (byte) (s >> 0);  
62.     }  
63.   
64.     /** 
65.      * 通过byte数组取到short 
66.      *  
67.      * @param b 
68.      * @param index 
69.      *            第几位开始取 
70.      * @return 
71.      */  
72.     public static short byteArray2short(byte[] b, int index) {  
73.         return (short) (((b[index + 1] << 8) | b[index + 0] & 0xff));  
74.     }  
75.   
76.     /** 
77.      * 字符到字节转换 
78.      *  
79.      * @param ch 
80.      * @return 
81.      */  
82.     public static void char2byteArray(byte[] bb, char ch, int index) {  
83.         int temp = (int) ch;  
84.         // byte[] b = new byte[2];  
85.         for (int i = 0; i < 2; i++) {  
86.             // 将最高位保存在最低位  
87.             bb[index + i] = new Integer(temp & 0xff).byteValue();  
88.             temp = temp >> 8; // 向右移8位  
89.         }  
90.     }  
91.   
92.     /** 
93.      * 字节到字符转换 
94.      *  
95.      * @param b 
96.      * @return 
97.      */  
98.     public static char byteArray2char(byte[] b, int index) {  
99.         int s = 0;  
100.         if (b[index + 1] > 0)  
101.             s += b[index + 1];  
102.         else  
103.             s += 256 + b[index + 0];  
104.         s *= 256;  
105.         if (b[index + 0] > 0)  
106.             s += b[index + 1];  
107.         else  
108.             s += 256 + b[index + 0];  
109.         char ch = (char) s;  
110.         return ch;  
111.     }  
112.       
113.     /** 
114.      * float转换byte 
115.      * 
116.      * @param bb 
117.      * @param x 
118.      * @param index 
119.      */  
120.     public static void float2byteArray(byte[] bb, float x, int index) {  
121.         // byte[] b = new byte[4];  
122.         int l = Float.floatToIntBits(x);  
123.         for (int i = 0; i < 4; i++) {  
124.             bb[index + i] = new Integer(l).byteValue();  
125.             l = l >> 8;  
126.         }  
127.     }  
128.   
129.     /** 
130.      * 通过byte数组取得float 
131.      * 
132.      * @param bb 
133.      * @param index 
134.      * @return 
135.      */  
136.     public static float byteArray2float(byte[] b, int index) {  
137.         int l;  
138.         l = b[index + 0];  
139.         l &= 0xff;  
140.         l |= ((long) b[index + 1] << 8);  
141.         l &= 0xffff;  
142.         l |= ((long) b[index + 2] << 16);  
143.         l &= 0xffffff;  
144.         l |= ((long) b[index + 3] << 24);  
145.         return Float.intBitsToFloat(l);  
146.     }  
147.       
148.     /** 
149.      * double转换byte 
150.      * 
151.      * @param bb 
152.      * @param x 
153.      * @param index 
154.      */  
155.     public static void double2byteArray(byte[] bb, double x, int index) {  
156.         // byte[] b = new byte[8];  
157.         long l = Double.doubleToLongBits(x);  
158.         for (int i = 0; i < 4; i++) {  
159.             bb[index + i] = new Long(l).byteValue();  
160.             l = l >> 8;  
161.         }  
162.     }  
163.   
164.     /** 
165.      * 通过byte数组取得double 
166.      * 
167.      * @param bb 
168.      * @param index 
169.      * @return 
170.      */  
171.     public static double byteArray2double(byte[] b, int index) {  
172.         long l;  
173.         l = b[0];  
174.         l &= 0xff;  
175.         l |= ((long) b[1] << 8);  
176.         l &= 0xffff;  
177.         l |= ((long) b[2] << 16);  
178.         l &= 0xffffff;  
179.         l |= ((long) b[3] << 24);  
180.         l &= 0xffffffffl;  
181.         l |= ((long) b[4] << 32);  
182.         l &= 0xffffffffffl;  
183.         l |= ((long) b[5] << 40);  
184.         l &= 0xffffffffffffl;  
185.         l |= ((long) b[6] << 48);  
186.         l &= 0xffffffffffffffl;  
187.         l |= ((long) b[7] << 56);  
188.         return Double.longBitsToDouble(l);  
189.     }  
190. }