java 大端序_Java字节序转换

/**

* 通信格式转换

*

* Java 和一些windows编程语言如c、c++、delphi所写的网络程序进行通讯时，需要进行相应的转换

* 高、低字节之间的转换

* windows的字节序为低字节开头

* linux,unix的字节序为高字节开头

* java则无论平台变化，都是高字节开头

*/

public   class  FormatTransfer {

/**

* 将 int转为低字节在前，高字节在后的byte数组

* @param n int

* @return byte[]

*/

public   static   byte [] toLH( int  n) {

byte [] b =  new   byte [ 4 ];

b[0 ] = ( byte ) (n &  0xff );

b[1 ] = ( byte ) (n >>  8  &  0xff );

b[2 ] = ( byte ) (n >>  16  &  0xff );

b[3 ] = ( byte ) (n >>  24  &  0xff );

return  b;

}

/**

* 将 int转为高字节在前，低字节在后的byte数组

* @param n int

* @return byte[]

*/

public   static   byte [] toHH( int  n) {

byte [] b =  new   byte [ 4 ];

b[3 ] = ( byte ) (n &  0xff );

b[2 ] = ( byte ) (n >>  8  &  0xff );

b[1 ] = ( byte ) (n >>  16  &  0xff );

b[0 ] = ( byte ) (n >>  24  &  0xff );

return  b;

}

/**

* 将 short转为低字节在前，高字节在后的byte数组

* @param n short

* @return byte[]

*/

public   static   byte [] toLH( short  n) {

byte [] b =  new   byte [ 2 ];

b[0 ] = ( byte ) (n &  0xff );

b[1 ] = ( byte ) (n >>  8  &  0xff );

return  b;

}

/**

* 将 short转为高字节在前，低字节在后的byte数组

* @param n short

* @return byte[]

*/

public   static   byte [] toHH( short  n) {

byte [] b =  new   byte [ 2 ];

b[1 ] = ( byte ) (n &  0xff );

b[0 ] = ( byte ) (n >>  8  &  0xff );

return  b;

}

/**

* 将 将int转为高字节在前，低字节在后的byte数组

public static byte[] toHH(int number) {

int temp = number;

byte[] b = new byte[4];

for (int i = b.length - 1; i > -1; i--) {

b = new Integer(temp & 0xff).byteValue();

temp = temp >> 8;

}

return b;

}

public static byte[] IntToByteArray(int i) {

byte[] abyte0 = new byte[4];

abyte0[3] = (byte) (0xff & i);

abyte0[2] = (byte) ((0xff00 & i) >> 8);

abyte0[1] = (byte) ((0xff0000 & i) >> 16);

abyte0[0] = (byte) ((0xff000000 & i) >> 24);

return abyte0;

}

*/

/**

* 将 float转为低字节在前，高字节在后的byte数组

*/

public   static   byte [] toLH( float  f) {

return  toLH(Float.floatToRawIntBits(f));

}

/**

* 将 float转为高字节在前，低字节在后的byte数组

*/

public   static   byte [] toHH( float  f) {

return  toHH(Float.floatToRawIntBits(f));

}

/**

* 将 String转为byte数组

*/

public   static   byte [] stringToBytes(String s,  int  length) {

while  (s.getBytes().length 

s += " " ;

}

return  s.getBytes();

}

/**

* 将 字节数组转换为String

* @param b byte[]

* @return String

*/

public   static  String bytesToString( byte [] b) {

StringBuffer result = new  StringBuffer( "" );

int  length = b.length;

for  ( int  i= 0 ; i

result.append((char )(b &  0xff ));

}

return  result.toString();

}

/**

* 将 字符串转换为byte数组

* @param s String

* @return byte[]

*/

public   static   byte [] stringToBytes(String s) {

return  s.getBytes();

}

/**

* 将 高字节数组转换为int

* @param b byte[]

* @return int

*/

public   static   int  hBytesToInt( byte [] b) {

int  s =  0 ;

for  ( int  i =  0 ; i 

if  (b >=  0 ) {

s = s + b;

} else  {

s = s + 256  + b;

}

s = s * 256 ;

}

if  (b[ 3 ] >=  0 ) {

s = s + b[3 ];

} else  {

s = s + 256  + b[ 3 ];

}

return  s;

}

/**

* 将 低字节数组转换为int

* @param b byte[]

* @return int

*/

public   static   int  lBytesToInt( byte [] b) {

int  s =  0 ;

for  ( int  i =  0 ; i 

if  (b[ 3 -i] >=  0 ) {

s = s + b[3 -i];

} else  {

s = s + 256  + b[ 3 -i];

}

s = s * 256 ;

}

if  (b[ 0 ] >=  0 ) {

s = s + b[0 ];

} else  {

s = s + 256  + b[ 0 ];

}

return  s;

}

/**

* 高 字节数组到short的转换

* @param b byte[]

* @return short

*/

public   static   short  hBytesToShort( byte [] b) {

int  s =  0 ;

if  (b[ 0 ] >=  0 ) {

s = s + b[0 ];

} else  {

s = s + 256  + b[ 0 ];

}

s = s * 256 ;

if  (b[ 1 ] >=  0 ) {

s = s + b[1 ];

} else  {

s = s + 256  + b[ 1 ];

}

short  result = ( short )s;

return  result;

}

/**

* 低 字节数组到short的转换

* @param b byte[]

* @return short

*/

public   static   short  lBytesToShort( byte [] b) {

int  s =  0 ;

if  (b[ 1 ] >=  0 ) {

s = s + b[1 ];

} else  {

s = s + 256  + b[ 1 ];

}

s = s * 256 ;

if  (b[ 0 ] >=  0 ) {

s = s + b[0 ];

} else  {

s = s + 256  + b[ 0 ];

}

short  result = ( short )s;

return  result;

}

/**

* 高 字节数组转换为float

* @param b byte[]

* @return float

*/

public   static   float  hBytesToFloat( byte [] b) {

int  i =  0 ;

Float F = new  Float( 0.0 );

i = ((((b[0 ]& 0xff )<

return  F.intBitsToFloat(i);

}

/**

* 低 字节数组转换为float

* @param b byte[]

* @return float

*/

public   static   float  lBytesToFloat( byte [] b) {

int  i =  0 ;

Float F = new  Float( 0.0 );

i = ((((b[3 ]& 0xff )<

return  F.intBitsToFloat(i);

}

/**

* 将 byte数组中的元素倒序排列

*/

public   static   byte [] bytesReverseOrder( byte [] b) {

int  length = b.length;

byte [] result =  new   byte [length];

for ( int  i= 0 ; i

result[length-i-1 ] = b;

}

return  result;

}

/**

* 打 印byte数组

*/

public   static   void  printBytes( byte [] bb) {

int  length = bb.length;

for  ( int  i= 0 ; i

System.out.print(bb + " " );

}

System.out.println("" );

}

public   static   void  logBytes( byte [] bb) {

int  length = bb.length;

String out = "" ;

for  ( int  i= 0 ; i

out = out + bb + " " ;

}

}

/**

* 将 int类型的值转换为字节序颠倒过来对应的int值

* @param i int

* @return int

*/

public   static   int  reverseInt( int  i) {

int  result = FormatTransfer.hBytesToInt(FormatTransfer.toLH(i));

return  result;

}

/**

* 将 short类型的值转换为字节序颠倒过来对应的short值

* @param s short

* @return short

*/

public   static   short  reverseShort( short  s) {

short  result = FormatTransfer.hBytesToShort(FormatTransfer.toLH(s));

return  result;

}

/**

* 将 float类型的值转换为字节序颠倒过来对应的float值

* @param f float

* @return float

*/

public   static   float  reverseFloat( float  f) {

float  result = FormatTransfer.hBytesToFloat(FormatTransfer.toLH(f));

return  result;

}

}