字节转换

java 和C 语言在实现通信的时候，jni 是一种方式，另外的一种凡是就是socket 通信；所谓的socket通信，通用的方式是字节在网络间的传输，这样的二进制码在网络

间传输，可以很好的服务于运用。

下面贴上socket通信见常见类型的转换方式。

项目中使用到的转换类：

public class DataConvert
{
    public List StringArrayToList(String[] strArray)
    {
        List list = new ArrayList();
        for(int i=0; i<strArray.length; i++)
        {
            list.add(new OptionsInt(i,strArray[i]));
        }
        return list;
    }
    
    /**将int转为低字节在前，高字节在后的byte数组
     * @param i
     * @return
     */
    public static byte[] intToByteArray(int num) {   
        
        byte a[] = new byte[4];
        for (int i = 0; i < 4; i++) {
            a[i] = (byte) ((num >> (i * 8)) & 0xff);
        }
        return a;
        
         }
    /**将int转为高字节在前，低字节在后的byte数组
     * @param i
     * @return
     */
    public static byte[] convertIntTo(int i) {
    
        byte[] result = new byte[4];   
          result[0] = (byte)((i >> 24) & 0xFF);
          result[1] = (byte)((i >> 16) & 0xFF);
          result[2] = (byte)((i >> 8) & 0xFF);
          result[3] = (byte)(i & 0xFF);
          return result;
    }
    
    /**
     *
     * @param c
     * @return
     */
    public static byte[] charToByte(char c) {
        byte[] b = new byte[2];
        b[0] = (byte) ((c & 0xFF00) >> 8);
        b[1] = (byte) (c & 0xFF);
        return b;
    }
    
    public static byte[] longToByte(long number) {
        long temp = number;
        byte[] b =new byte[8];
        for(int i =0; i < b.length; i++){
            b[i]=new Long(temp &0xff).byteValue();//
            temp = temp >>8;// 向右移8位
        }
        return b;
    }
    public static byte[] long2bytes(long num) {
           byte[] b = new byte[8];
           for (int i = 0; i < 8; i++) {
            b[i] = (byte) (num >>> (56 - i * 8));
           }
           return b;
        }
     /**
     * 将低字节数组转换为int
     * @param b byte[]
     * @return int
     */  
   public static int lBytesToInt(byte[] b) {  
       return    b[3] & 0xff
       | (b[2] & 0xff) << 8
       | (b[1] & 0xff) << 16
       | (b[0] & 0xff) << 24;
   }   
    /**
     *
     *转为低字节在前，高字节在后的int
     * @param n int
     * @return byte[]
     */
  public static int bytesToInt(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;  
    
    }
  /**
   * 转为低字节在前，高字节在后的int
   * @param b
   * @return l
   */
  public static long bytesToLong(byte[] b) {
      long l = 0;

      l = b[0];

      l |= ((long) b[1] << 8);

      l |= ((long) b[2] << 16);

      l |= ((long) b[3] << 24);

      l |= ((long) b[4] << 32);

      l |= ((long) b[5] << 40);

      l |= ((long) b[6] << 48);

      l |= ((long) b[7] << 56);

      return l;
  }
      /**将short转为低字节在前，高字节在后的byte数组
     * @param n
     * @return
     */
  public static byte[] shortToBytes(short n) {
//      byte[] b = new byte[2];
//      b[1] = (byte) (n & 0xff);
//      b[0] = (byte) ((n >> 8) & 0xff);
      byte[] b = new byte[2];  
      b[0] = (byte) (n & 0xff);  
      b[1] = (byte) (n >> 8 & 0xff);  
      
      return b;
      }
 
  /**
   * 低字节数组到short的转换
 * @param b
 * @return
 */
  public static short bytesToShort(byte[] b) {
//      return (short) (b[1] & 0xff
//      | (b[0] & 0xff) << 8);
      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;  
  }
 
  /**
   * 系统提供的数组拷贝方法arraycopy
   * */
  public static byte[] sysCopy(List<byte[]> srcArrays) {
 
   int len = 0;
   for (byte[] srcArray:srcArrays) {
    len+= srcArray.length;
   }
      byte[] destArray = new byte[len];   
      int destLen = 0;
      for (byte[] srcArray:srcArrays) {
          System.arraycopy(srcArray, 0, destArray, destLen, srcArray.length);   
          destLen += srcArray.length;   
      }   
      return destArray;
  }  
 
  /**
   * 浮点转换为字节
   *  
   * @param f
   * @return
   */  
  public static byte[] float2byte(float f) {  
        
      // 把float转换为byte[]  
      int fbit = Float.floatToIntBits(f);  
        
      byte[] b = new byte[4];    
      for (int i = 0; i < 4; i++) {    
          b[i] = (byte) (fbit >> (24 - i * 8));    
      }   
        
      // 翻转数组  
      int len = b.length;  
      // 建立一个与源数组元素类型相同的数组  
      byte[] dest = new byte[len];  
      // 为了防止修改源数组，将源数组拷贝一份副本  
      System.arraycopy(b, 0, dest, 0, len);  
      byte temp;  
      // 将顺位第i个与倒数第i个交换  
      for (int i = 0; i < len / 2; ++i) {  
          temp = dest[i];  
          dest[i] = dest[len - i - 1];  
          dest[len - i - 1] = temp;  
      }  
        
      return dest;  
        
  }  
    
  /**
   * 字节转换为浮点
   *  
   * @param b 字节（至少4个字节）
   * @param index 开始位置
   * @return
   */  
  public static float byte2float(byte[] b, int index) {    
      int l;                                             
      l = b[index + 0];                                  
      l &= 0xff;                                         
      l |= ((long) b[index + 1] << 8);                   
      l &= 0xffff;                                       
      l |= ((long) b[index + 2] << 16);                  
      l &= 0xffffff;                                     
      l |= ((long) b[index + 3] << 24);                  
      return Float.intBitsToFloat(l);                    
  }
}

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\n", 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\n",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\n",b);
        long l = b;
        System.out.print("Println byte to long:");
        System.out.println(l);
        System.out.printf("printf byte to long:%X\n",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\n",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\n",0x11f2f3f4f5f6f7f8l);
        System.out.println("println byte2Hex(longToBytes(0x11f2f3f4f5f6f7f8l))"+byte2Hex(longToBytes(0x11f2f3f4f5f6f7f8l)));
        // 注意，下面的这行，并不能获得正确的uint。
        System.out.printf("printf bytesToUint(longToBytes(0x11f2f3f4f5f6f7f8l):%X\n",bytesToUint(longToBytes(0x11f2f3f4f5f6f7f8l)));
        
        System.out.println("===============bytesToLong(longToBytes())==============");
        System.out.println(bytesToLong(longToBytes(0x11f2f3f4f5f6f7f8l)));
        System.out.printf("%X\n",bytesToLong(longToBytes(0x11f2f3f4f5f6f7f8l)));
        
        testShortConvert();
        testUshortConvert();
        testUbyteConvert();
    }


}