Java字节序转换
源文档 <http://origin100.javaeye.com/blog/267165>
| /** |
| * 通信格式转换 |
| * |
| * 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; |
| } |
| } |