Go语言视频零基础入门到精通

javalearner

1. /**  
   
2. * 通信格式转换  
   
3. *  
   
4. * Java 和一些windows编程语言如c、c++、delphi所写的网络程序进行通讯时，需要进行相应的转换  
   
5. * 高、低字节之间的转换  
   
6. * windows的字节序为低字节开头  
   
7. * linux,unix的字节序为高字节开头  
   
8. * java则无论平台变化，都是高字节开头  
   
9.    */   
   
10.    
    
11.    
    
12. public   class  FormatTransfer {  
    
13. /**  
    
14.    * 将 int转为低字节在前，高字节在后的byte数组  
    
15.    * @param n int  
    
16.    * @return byte[]  
    
17.    */   
    
18. public   static   byte [] toLH( int  n) {  
    
19.    byte [] b =  new   byte [ 4 ];  
    
20.    b[0 ] = ( byte ) (n &  0xff );  
    
21.    b[1 ] = ( byte ) (n >>  8  &  0xff );  
    
22.    b[2 ] = ( byte ) (n >>  16  &  0xff );  
    
23.    b[3 ] = ( byte ) (n >>  24  &  0xff );  
    
24.    return  b;  
    
25. }   
    
26.    
    
27.    
    
28. /**  
    
29.    * 将 int转为高字节在前，低字节在后的byte数组  
    
30.    * @param n int  
    
31.    * @return byte[]  
    
32.    */   
    
33. public   static   byte [] toHH( int  n) {  
    
34.    byte [] b =  new   byte [ 4 ];  
    
35.    b[3 ] = ( byte ) (n &  0xff );  
    
36.    b[2 ] = ( byte ) (n >>  8  &  0xff );  
    
37.    b[1 ] = ( byte ) (n >>  16  &  0xff );  
    
38.    b[0 ] = ( byte ) (n >>  24  &  0xff );  
    
39.    return  b;  
    
40. }   
    
41.    
    
42. /**  
    
43.    * 将 short转为低字节在前，高字节在后的byte数组  
    
44.    * @param n short  
    
45.    * @return byte[]  
    
46.    */   
    
47. public   static   byte [] toLH( short  n) {  
    
48.    byte [] b =  new   byte [ 2 ];  
    
49.    b[0 ] = ( byte ) (n &  0xff );  
    
50.    b[1 ] = ( byte ) (n >>  8  &  0xff );  
    
51.    return  b;  
    
52. }
    
53. 
    
54.    
    
55. /**  
    
56.    * 将 short转为高字节在前，低字节在后的byte数组  
    
57.    * @param n short  
    
58.    * @return byte[]  
    
59.    */   
    
60. public   static   byte [] toHH( short  n) {  
    
61.    byte [] b =  new   byte [ 2 ];  
    
62.    b[1 ] = ( byte ) (n &  0xff );  
    
63.    b[0 ] = ( byte ) (n >>  8  &  0xff );  
    
64.    return  b;  
    
65. }   
    
66.    
    
67.    
    
68.    
    
69. /**  
    
70.    * 将将int转为高字节在前，低字节在后的byte数组   
    
71. public static byte[] toHH(int number) {  
    
72.    int temp = number;  
    
73.    byte[] b = new byte[4];  
    
74.    for (int i = b.length - 1; i > -1; i--) {  
    
75.      b = new Integer(temp & 0xff).byteValue();  
    
76.      temp = temp >> 8;  
    
77.    }  
    
78.    return b;  
    
79. }   
    
80. public static byte[] IntToByteArray(int i) {  
    
81.      byte[] abyte0 = new byte[4];  
    
82.      abyte0[3] = (byte) (0xff & i);  
    
83.      abyte0[2] = (byte) ((0xff00 & i) >> 8);  
    
84.      abyte0[1] = (byte) ((0xff0000 & i) >> 16);  
    
85.      abyte0[0] = (byte) ((0xff000000 & i) >> 24);  
    
86.      return abyte0;  
    
87. }   
    
88. */   
    
89.    
    
90. /**  
    
91.    * 将 float转为低字节在前，高字节在后的byte数组  
    
92.    */   
    
93. public   static   byte [] toLH( float  f) {  
    
94.    return  toLH(Float.floatToRawIntBits(f));  
    
95. }   
    
96. /**  
    
97.    * 将 float转为高字节在前，低字节在后的byte数组  
    
98.    */   
    
99. public   static   byte [] toHH( float  f) {  
    
100.    return  toHH(Float.floatToRawIntBits(f));  
     
101. }
     
102. 
     
103.    
     
104. /**  
     
105.    * 将 String转为byte数组  
     
106.    */   
     
107. public   static   byte [] stringToBytes(String s,  int  length) {  
     
108.    while  (s.getBytes().length < length) {  
     
109.      s += " " ;  
     
110.    }  
     
111.    return  s.getBytes();  
     
112. }   
     
113.    
     
114.    
     
115. /**  
     
116.    * 将字节数组转换为String  
     
117.    * @param b byte[]  
     
118.    * @return String  
     
119.    */   
     
120. public   static  String bytesToString( byte [] b) {  
     
121.    StringBuffer result = new  StringBuffer( "" );  
     
122.    int  length = b.length;  
     
123.    for  ( int  i= 0 ; i< length; i++) {  
     
124.      result.append((char )(b[i] &  0xff ));  
     
125.    }  
     
126.    return  result.toString();  
     
127. }
     
128. 
     
129.    
     
130. /**  
     
131.    * 将字符串转换为byte数组  
     
132.    * @param s String  
     
133.    * @return byte[]  
     
134.    */   
     
135. public   static   byte [] stringToBytes(String s) {  
     
136.    return  s.getBytes();  
     
137. }
     
138. 
     
139.    
     
140. /**  
     
141.    * 将高字节数组转换为int  
     
142.    * @param b byte[]  
     
143.    * @return int  
     
144.    */   
     
145. public   static   int  hBytesToInt( byte [] b) {  
     
146.    int  s =  0 ;  
     
147.    for  ( int  i =  0 ; i <  3 ; i++) {  
     
148.      if  (b[i] >=  0 ) {  
     
149.      s = s + b[i];  
     
150.      } else  {  
     
151.      s = s + 256  + b[i];  
     
152.      }  
     
153.      s = s * 256 ;  
     
154.    }  
     
155.    if  (b[ 3 ] >=  0 ) {  
     
156.      s = s + b[3 ];  
     
157.    } else  {  
     
158.      s = s + 256  + b[ 3 ];  
     
159.    }  
     
160.    return  s;  
     
161. }
     
162. 
     
163.    
     
164. /**  
     
165.    * 将低字节数组转换为int  
     
166.    * @param b byte[]  
     
167.    * @return int  
     
168.    */   
     
169. public   static   int  lBytesToInt( byte [] b) {  
     
170.    int  s =  0 ;  
     
171.    for  ( int  i =  0 ; i <  3 ; i++) {  
     
172.      if  (b[ 3 -i] >=  0 ) {  
     
173.      s = s + b[3 -i];  
     
174.      } else  {  
     
175.      s = s + 256  + b[ 3 -i];  
     
176.      }  
     
177.      s = s * 256 ;  
     
178.    }  
     
179.    if  (b[ 0 ] >=  0 ) {  
     
180.      s = s + b[0 ];  
     
181.    } else  {  
     
182.      s = s + 256  + b[ 0 ];  
     
183.    }  
     
184.    return  s;  
     
185. }   
     
186.    
     
187.    
     
188. /**  
     
189.    * 高字节数组到short的转换  
     
190.    * @param b byte[]  
     
191.    * @return short  
     
192.    */   
     
193. public   static   short  hBytesToShort( byte [] b) {  
     
194.    int  s =  0 ;  
     
195.    if  (b[ 0 ] >=  0 ) {  
     
196.      s = s + b[0 ];  
     
197.      } else  {  
     
198.      s = s + 256  + b[ 0 ];  
     
199.      }  
     
200.      s = s * 256 ;  
     
201.    if  (b[ 1 ] >=  0 ) {  
     
202.      s = s + b[1 ];  
     
203.    } else  {  
     
204.      s = s + 256  + b[ 1 ];  
     
205.    }  
     
206.    short  result = ( short )s;  
     
207.    return  result;  
     
208. }
     
209. 
     
210.    
     
211. /**  
     
212.    * 低字节数组到short的转换  
     
213.    * @param b byte[]  
     
214.    * @return short  
     
215.    */   
     
216. public   static   short  lBytesToShort( byte [] b) {  
     
217.    int  s =  0 ;  
     
218.    if  (b[ 1 ] >=  0 ) {  
     
219.      s = s + b[1 ];  
     
220.      } else  {  
     
221.      s = s + 256  + b[ 1 ];  
     
222.      }  
     
223.      s = s * 256 ;  
     
224.    if  (b[ 0 ] >=  0 ) {  
     
225.      s = s + b[0 ];  
     
226.    } else  {  
     
227.      s = s + 256  + b[ 0 ];  
     
228.    }  
     
229.    short  result = ( short )s;  
     
230.    return  result;  
     
231. }
     
232. 
     
233.    
     
234. /**  
     
235.    * 高字节数组转换为float  
     
236.    * @param b byte[]  
     
237.    * @return float  
     
238.    */   
     
239. public   static   float  hBytesToFloat( byte [] b) {  
     
240.    int  i =  0 ;  
     
241.    Float F = new  Float( 0.0 );  
     
242.    i = ((((b[0 ]& 0xff )<< 8  | (b[ 1 ]& 0xff ))<< 8 ) | (b[ 2 ]& 0xff ))<< 8  | (b[ 3 ]& 0xff );  
     
243.    return  F.intBitsToFloat(i);  
     
244. }
     
245. 
     
246.    
     
247. /**  
     
248.    * 低字节数组转换为float  
     
249.    * @param b byte[]  
     
250.    * @return float  
     
251.    */   
     
252. public   static   float  lBytesToFloat( byte [] b) {  
     
253.    int  i =  0 ;  
     
254.    Float F = new  Float( 0.0 );  
     
255.    i = ((((b[3 ]& 0xff )<< 8  | (b[ 2 ]& 0xff ))<< 8 ) | (b[ 1 ]& 0xff ))<< 8  | (b[ 0 ]& 0xff );  
     
256.    return  F.intBitsToFloat(i);  
     
257. }
     
258. 
     
259.    
     
260. /**  
     
261.    * 将 byte数组中的元素倒序排列  
     
262.    */   
     
263. public   static   byte [] bytesReverseOrder( byte [] b) {  
     
264.    int  length = b.length;  
     
265.    byte [] result =  new   byte [length];  
     
266.    for ( int  i= 0 ; i< length; i++) {  
     
267.      result[length-i-1 ] = b[i];  
     
268.    }  
     
269.    return  result;  
     
270. }
     
271. 
     
272.    
     
273. /**  
     
274.    * 打印byte数组  
     
275.    */   
     
276. public   static   void  printBytes( byte [] bb) {  
     
277.    int  length = bb.length;  
     
278.    for  ( int  i= 0 ; i< length; i++) {  
     
279.      System.out.print(bb + " " );  
     
280.    }  
     
281.    System.out.println("" );  
     
282. }   
     
283.    
     
284. public   static   void  logBytes( byte [] bb) {  
     
285.    int  length = bb.length;  
     
286.    String out = "" ;  
     
287.    for  ( int  i= 0 ; i< length; i++) {  
     
288.      out = out + bb + " " ;  
     
289.    }   
     
290.    
     
291. }   
     
292.    
     
293. /**  
     
294.    * 将 int类型的值转换为字节序颠倒过来对应的int值  
     
295.    * @param i int  
     
296.    * @return int  
     
297.    */   
     
298. public   static   int  reverseInt( int  i) {  
     
299.    int  result = FormatTransfer.hBytesToInt(FormatTransfer.toLH(i));  
     
300.    return  result;  
     
301. }   
     
302.    
     
303. /**  
     
304.    * 将 short类型的值转换为字节序颠倒过来对应的short值  
     
305.    * @param s short  
     
306.    * @return short  
     
307.    */   
     
308. public   static   short  reverseShort( short  s) {  
     
309.    short  result = FormatTransfer.hBytesToShort(FormatTransfer.toLH(s));  
     
310.    return  result;  
     
311. }   
     
312.    
     
313. /**  
     
314.    * 将 float类型的值转换为字节序颠倒过来对应的float值  
     
315.    * @param f float  
     
316.    * @return float  
     
317.    */   
     
318. public   static   float  reverseFloat( float  f) {  
     
319.    float  result = FormatTransfer.hBytesToFloat(FormatTransfer.toLH(f));  
     
320.    return  result;  
     
321. }   
     
322.    
     
323. }  

复制代码

  
  
   
   

     
   

     
   
  

复制代码

源码下载：http://file.javaxxz.com/2014/10/28/235619500.zip