Java字节序转换

最新推荐文章于 2023-09-06 09:09:53 发布

antswallow

最新推荐文章于 2023-09-06 09:09:53 发布

阅读量5.9k

点赞数

CC 4.0 BY-SA版权

分类专栏： JAVA 文章标签： java byte float delphi windows string

本文链接：https://blog.youkuaiyun.com/antswallow/article/details/5477047

JAVA 专栏收录该内容

121 篇文章

订阅专栏

/**
* 通信格式转换
*
* 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 < 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<length; 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 < 3 ; 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 < 3 ; 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 )<< 8 | (b[ 1 ]& 0xff ))<< 8 ) | (b[ 2 ]& 0xff ))<< 8 | (b[ 3 ]& 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 )<< 8 | (b[ 2 ]& 0xff ))<< 8 ) | (b[ 1 ]& 0xff ))<< 8 | (b[ 0 ]& 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<length; i++) {
result[length-i-1 ] = b;
}
return result;
}
/**
* 打印byte数组
*/
public static void printBytes( byte [] bb) {
int length = bb.length;
for ( int i= 0 ; i<length; 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<length; 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;
}
}