网络字节序转换

相当方便实用的一个工具类，原始链接已不可知，改正了一些小错误

——————————————————————————————————————————————————————————

 

/**  
* 通信格式转换 
* 
* 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[i] & 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[i] >= 0) {  
        s = s + b[i];  
        }  else {  
        s = s + 256 + b[i];  
        }  
        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;  
      i = ((((b[0]&0xff)<<8 | (b[1]&0xff))<<8) | (b[2]&0xff))<<8 | (b[3]&0xff);  
       return Float.intBitsToFloat(i);  
    }   
      
     /**  
      * 低字节数组转换为float 
      *  @param  b byte[] 
      *  @return  float 
       */  
     public  static  float lBytesToFloat( byte[] b) {  
       int i = 0;  
      i = ((((b[3]&0xff)<<8 | (b[2]&0xff))<<8) | (b[1]&0xff))<<8 | (b[0]&0xff);  
       return Float.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[i];  
      }  
       return result;  
    }   
      
     /**  
      * 打印byte数组 
       */  
     public  static  void printBytes( byte[] bb) {  
       int length = bb.length;  
       for ( int i=0; i<length; i++) {  
        System.out.print(bb[i] + " ");  
      }  
      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[i] + " ";  
      }   
      
    }   
      
     /**  
      * 将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;  
    }   
}

转载于:https://www.cnblogs.com/cuizhf/archive/2012/01/13/2321172.html