java整型数与网络字节序的 byte[] 数组转换关系

java整型数与网络字节序的 byte[] 数组转换关系

 　工作项目需要在java和c/c++之间进行socket通信，socket通信是以字节流或者字节包进行的，socket发送方须将数据转换为字节流或者字节包，而接收方则将字节流和字节包再转换回相应的数据类型。如果发送方和接收方都是同种语言，则一般只涉及到字节序的调整。而对于java和c/c++的通信，则情况就要复杂一些，主要是因为java中没有unsigned类型，并且java和c在某些数据类型上的长度不一致。

　　本文就是针对这种情况，整理了java数据类型和网络字节流或字节包(相当于java的byte数组)之间转换方法。实际上网上这方面的资料不少，但往往不全，甚至有些有错误，于是就花了点时间对java整型数和网络字节序的byte[]之间转换的各种情况做了一些验证和整理。整理出来的函数如下：

public class ByteConvert {

    // 以下 是整型数 和 网络字节序的  byte[] 数组之间的转换

    public static byte[] longToBytes(long n) {

        byte[] b = new byte[8];

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

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

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

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

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

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

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

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

        return b;

    }

    

    public static void longToBytes( long n, byte[] array, int offset ){

        array[7+offset] = (byte) (n & 0xff);

        array[6+offset] = (byte) (n >> 8 & 0xff);

        array[5+offset] = (byte) (n >> 16 & 0xff);

        array[4+offset] = (byte) (n >> 24 & 0xff);

        array[3+offset] = (byte) (n >> 32 & 0xff);

        array[2+offset] = (byte) (n >> 40 & 0xff);

        array[1+offset] = (byte) (n >> 48 & 0xff);

        array[0+offset] = (byte) (n >> 56 & 0xff);

    }

    

    public static long bytesToLong( byte[] array )

    {

        return ((((long) array[ 0] & 0xff) << 56)

              | (((long) array[ 1] & 0xff) << 48)

              | (((long) array[ 2] & 0xff) << 40)

              | (((long) array[ 3] & 0xff) << 32)

              | (((long) array[ 4] & 0xff) << 24)

              | (((long) array[ 5] & 0xff) << 16)

              | (((long) array[ 6] & 0xff) << 8) 

              | (((long) array[ 7] & 0xff) << 0));        

    }

    

    public static long bytesToLong( byte[] array, int offset )

    {

        return ((((long) array[offset + 0] & 0xff) << 56)

              | (((long) array[offset + 1] & 0xff) << 48)

              | (((long) array[offset + 2] & 0xff) << 40)

              | (((long) array[offset + 3] & 0xff) << 32)

              | (((long) array[offset + 4] & 0xff) << 24)

              | (((long) array[offset + 5] & 0xff) << 16)

              | (((long) array[offset + 6] & 0xff) << 8) 

              | (((long) array[offset + 7] & 0xff) << 0));            

    }

    

    public static byte[] intToBytes(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;

    }

    

    public static void intToBytes( int n, byte[] array, int offset ){

        array[3+offset] = (byte) (n & 0xff);

        array[2+offset] = (byte) (n >> 8 & 0xff);

        array[1+offset] = (byte) (n >> 16 & 0xff);

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

    }    

    public static int bytesToInt(byte b[]) {

        return    b[3] & 0xff 

               | (b[2] & 0xff) << 8 

               | (b[1] & 0xff) << 16

               | (b[0] & 0xff) << 24;

    }

    public static int bytesToInt(byte b[], int offset) {

        return    b[offset+3] & 0xff 

               | (b[offset+2] & 0xff) << 8 

               | (b[offset+1] & 0xff) << 16

               | (b[offset] & 0xff) << 24;

    }

    public static byte[] uintToBytes( long 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;

    }

    public static void uintToBytes( long n, byte[] array, int offset ){

        array[3+offset] = (byte) (n );

        array[2+offset] = (byte) (n >> 8 & 0xff);

        array[1+offset] = (byte) (n >> 16 & 0xff);

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

    }

    public static long bytesToUint(byte[] array) {  

        return ((long) (array[3] & 0xff))  

             | ((long) (array[2] & 0xff)) << 8  

             | ((long) (array[1] & 0xff)) << 16  

             | ((long) (array[0] & 0xff)) << 24;  

    }

    public static long bytesToUint(byte[] array, int offset) {   

        return ((long) (array[offset+3] & 0xff))  

              | ((long) (array[offset+2] & 0xff)) << 8  

             | ((long) (array[offset+1] & 0xff)) << 16  

             | ((long) (array[offset]   & 0xff)) << 24;  

    }

    public static byte[] shortToBytes(short n) {

        byte[] b = new byte[2];

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

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

        return b;

    }

    

    public static void shortToBytes(short n, byte[] array, int offset ) {        

        array[offset+1] = (byte) ( n       & 0xff);

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

    }

    

    public static short bytesToShort(byte[] b){

        return (short)( b[1] & 0xff

                      |(b[0] & 0xff) << 8 ); 

    }    

    public static short bytesToShort(byte[] b, int offset){

        return (short)( b[offset+1] & 0xff

                      |(b[offset]    & 0xff) << 8 ); 

    }

    public static byte[] ushortToBytes(int n) {

        byte[] b = new byte[2];

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

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

        return b;

    }    

    public static void ushortToBytes(int n, byte[] array, int offset ) {

        array[offset+1] = (byte) ( n       & 0xff);

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

    }

    public static int bytesToUshort(byte b[]) {

        return    b[1] & 0xff 

               | (b[0] & 0xff) << 8;

    }    

    public static int bytesToUshort(byte b[], int offset) {

        return    b[offset+1] & 0xff 

               | (b[offset]   & 0xff) << 8;

    }    

    public static byte[] ubyteToBytes( int n ){

        byte[] b = new byte[1];

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

        return b;

    }

    public static void ubyteToBytes( int n, byte[] array, int offset ){

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

    }

    public static int bytesToUbyte( byte[] array ){            

        return array[0] & 0xff;

    }        

    public static int bytesToUbyte( byte[] array, int offset ){            

        return array[offset] & 0xff;

    }    

    // char 类型、 float、double 类型和 byte[] 数组之间的转换关系还需继续研究实现。 

}

测试程序如下：

public class ByteConvertTest {

    

    public static String byte2Hex(byte[] buf) 

    {

        StringBuffer strbuf = new StringBuffer();

        strbuf.append("{");

        for (byte b : buf) 

        {

            if (b == 0) 

            {

                strbuf.append("00");

            } 

            else if (b == -1) 

            {

                strbuf.append("FF");

            } 

            else 

            {

                String str = Integer.toHexString(b).toUpperCase();

                // sb.append(a);

                if (str.length() == 8) 

                {

                    str = str.substring(6, 8);

                } 

                else if (str.length() < 2) 

                {

                    str = "0" + str;

                }

                strbuf.append(str);

            }

            strbuf.append(" ");

        }

        strbuf.append("}");

        return strbuf.toString();

    }    

    public static byte[] longToBytes(long n) {

        byte[] b = new byte[8];

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

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

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

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

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

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

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

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

        return b;

    }

    public static long bytesToLong( byte[] array )

    {

        return ((((long) array[ 0] & 0xff) << 56)

              | (((long) array[ 1] & 0xff) << 48)

              | (((long) array[ 2] & 0xff) << 40)

              | (((long) array[ 3] & 0xff) << 32)

              | (((long) array[ 4] & 0xff) << 24)

              | (((long) array[ 5] & 0xff) << 16)

              | (((long) array[ 6] & 0xff) << 8) 

              | (((long) array[ 7] & 0xff) ));        

    }

    

    public static int bytesToInt(byte b[]) {

        return    b[3] & 0xff 

               | (b[2] & 0xff) << 8 

               | (b[1] & 0xff) << 16

               | (b[0] & 0xff) << 24;

    }

    public static long bytesToUint(byte[] array) {  

        return ((long) (array[3] & 0xff))  

             | ((long) (array[2] & 0xff)) << 8  

             | ((long) (array[1] & 0xff)) << 16  

             | ((long) (array[0] & 0xff)) << 24;  

    }

    public static byte[] uintToBytes( long 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;

    }

    

    public static byte[] shortToBytes(short n) {

        byte[] b = new byte[2];

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

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

        return b;

    }

    

    public static short bytesToShort(byte[] b){

        return (short)( b[1] & 0xff

                      |(b[0] & 0xff) << 8 ); 

    }

    

    static void testShortConvert(){

        System.out.println("=================== short convert =============");

        System.out.println("byte2Hex(shortToBytes((short)0x11f2))"+byte2Hex(shortToBytes((short)0x11f2)));        

        System.out.print("println 0x11f2:");

        System.out.println((short)0x11f2);        

        System.out.println("byte2Hex(shortToBytes((short)0xf1f2))"+byte2Hex(shortToBytes((short)0xf1f2)));        

        System.out.print("println 0xf1f2:");

        System.out.println((short)0xf1f2);            

        System.out.print("println bytesToShort(shortToBytes((short)0x11f2)):");

        System.out.println((short)bytesToShort(shortToBytes((short)0x11f2)));            

        System.out.print("println bytesToShort(shortToBytes((short)0xf1f2)):");

        System.out.println((short)bytesToShort(shortToBytes((short)0xf1f2)));        

    }

    

    public static byte[] ushortToBytes(int n) {

        byte[] b = new byte[2];

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

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

        return b;

    }

    

    public static int bytesToUshort(byte b[]) {

        return    b[1] & 0xff 

               | (b[0] & 0xff) << 8;

    }

    static void testUshortConvert(){

        System.out.println("=================== Ushort convert =============");

        System.out.println("byte2Hex(ushortToBytes(0x11f2))"+byte2Hex(ushortToBytes(0x11f2)));        

        System.out.print("println 0x11f2:");

        System.out.println(0x11f2);        

        System.out.println("byte2Hex(ushortToBytes(0xf1f2))"+byte2Hex(ushortToBytes(0xf1f2)));        

        System.out.print("println 0xf1f2:");

        System.out.println(0xf1f2);            

        System.out.print("println bytesToUshort(ushortToBytes(0x11f2)):");

        System.out.println(bytesToUshort(ushortToBytes(0x11f2)));            

        System.out.print("println bytesToUshort(ushortToBytes(0xf1f2)):");

        System.out.println(bytesToUshort(ushortToBytes(0xf1f2)));        

    }

    

    public static byte[] ubyteToBytes( int n ){

        byte[] b = new byte[1];

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

        return b;

    }

    public static int bytesToUbyte( byte[] array ){            

        return array[0] & 0xff;

    }    

    static void testUbyteConvert(){

        System.out.println("=================== Ubyte convert =============");

        System.out.println("byte2Hex(ubyteToBytes(0x1112))"+byte2Hex(ubyteToBytes(0x1112)));        

        System.out.print("println 0x1112:");

        System.out.println(0x1112);        

        System.out.println("byte2Hex(ubyteToBytes(0xf2))"+byte2Hex(ubyteToBytes(0xf2)));        

        System.out.print("println 0xf2:");

        System.out.println(0xf2);            

        System.out.print("println bytesToUbyte(ubyteToBytes(0x1112)):");

        System.out.println(bytesToUbyte(ubyteToBytes(0x1112)));            

        System.out.print("println bytesToUbyte(ubyteToBytes(0xf1f2)):");

        System.out.println(bytesToUbyte(ubyteToBytes(0xf1f2)));        

    }

    

    

    /**

     * @param args

     */

    public static void main(String[] args) {

        // TODO Auto-generated method stub        

        byte[] array = new byte[4];

        array[3] = (byte) 0xF4;

        array[2] = 0x13;

        array[1] = 0x12;

        array[0] = 0x11;

        

        System.out.println("=================== Integer bytes =============");

        

        System.out.println("the bytes is:"+byte2Hex(array) );

        System.out.print("println bytesToInt :");

        System.out.println( bytesToInt(array));

        System.out.printf("printf bytesToInt :%X ", bytesToInt(array));

        

        System.out.println("=================== long bytes =============");

        byte[] longBytes = new byte[8];

        

        longBytes[7] = (byte) 0xf7;

        longBytes[6] = (byte) 0x16;

        longBytes[5] = (byte) 0xf5;

        longBytes[4] = (byte) 0x14;

        longBytes[3] = (byte) 0xf3;

        longBytes[2] = (byte) 0x12;

        longBytes[1] = (byte) 0xf1;

        longBytes[0] = (byte) 0x10;

        

        System.out.println( "the bytes is:"+byte2Hex(longBytes) );

        System.out.printf("printf bytesToLong:%X ",bytesToLong(longBytes));

        

        System.out.println("=================byte to long ================");

        

        byte b = (byte)0xf1;

        System.out.print("Println the byte:");

        System.out.println(b);

        System.out.printf("Printf the byte:%X ",b);

        long l = b;

        System.out.print("Println byte to long:");

        System.out.println(l);

        System.out.printf("printf byte to long:%X ",l);

        

        System.out.println("================= uint Bytes ================");

        

        byte[] uint = new byte[4];

        uint[3] = (byte) 0xf3;

        uint[2] = (byte) 0x12;

        uint[1] = (byte) 0xf1;

        uint[0] = (byte) 0xFF;

        

        System.out.println( "the bytes is:"+byte2Hex(uint) );

        System.out.printf("printf bytesToUint:%X ",bytesToUint(uint));

        System.out.print("Println bytesToUint:");

        System.out.println(bytesToUint(uint));

        System.out.println("byte2Hex(uintToBytes(0x11f2f3f4f5f6f7f8l)):"+byte2Hex(uintToBytes(0x11f2f3f4f5f6f7f8l)));

        

        System.out.println("===============Long Integer==============");        

        System.out.print("println 0x11f2f3f4f5f6f7f8l:");

        System.out.println(0x11f2f3f4f5f6f7f8l);        

        System.out.printf("Printf 0x11f2f3f4f5f6f7f8l:%X ",0x11f2f3f4f5f6f7f8l);

        System.out.println("println byte2Hex(longToBytes(0x11f2f3f4f5f6f7f8l))"+byte2Hex(longToBytes(0x11f2f3f4f5f6f7f8l)));

        // 注意，下面的这行，并不能获得正确的uint。

        System.out.printf("printf bytesToUint(longToBytes(0x11f2f3f4f5f6f7f8l):%X ",bytesToUint(longToBytes(0x11f2f3f4f5f6f7f8l)));

        

        System.out.println("===============bytesToLong(longToBytes())==============");

        System.out.println(bytesToLong(longToBytes(0x11f2f3f4f5f6f7f8l)));

        System.out.printf("%X ",bytesToLong(longToBytes(0x11f2f3f4f5f6f7f8l)));

        

        testShortConvert();

        testUshortConvert();

        testUbyteConvert();

    }

}