basetype.java

基于UDP的可靠邮件系统

package org.hwmhere.util.math;

public class BaseType {

		
	/**
	 * 将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[i] = 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;
	    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[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 = BaseType.hBytesToInt(BaseType.toLH(i));
	    return result;
	  } 

	  /**
		 * 将short类型的值转换为字节序颠倒过来对应的short值
		 * 
		 * @param s short
		 * @return short
		 */
	  public static short reverseShort(short s) {
	    short result = BaseType.hBytesToShort(BaseType.toLH(s));
	    return result;
	  } 

	  /**
		 * 将float类型的值转换为字节序颠倒过来对应的float值
		 * 
		 * @param f float
		 * @return float
		 */
	  public static float reverseFloat(float f) {
	    float result = BaseType.hBytesToFloat(BaseType.toLH(f));
	    return result;
	  } 


	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}