基本类型转换，高性能

package util;

import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.util.Arrays;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class TypeCase {
	private TypeCase(){}
	private static  Log logger=LogFactory.getLog(TypeCase.class);
	
	    public static  byte[] stringTobytes(String cs,int len) {
	    	byte[] bs2 = new byte[len];
	    	  for(int i = 0; i < cs.length(); i++) {
	    		  bs2[i] = (byte) cs.charAt(i);
	    	   }
			return bs2;
	    	 }
		  public static  String bytesToString(byte[] b) {  
			  char[] str = new char[b.length];
				 for (int j = 0; j <b.length; j++) {
					 str[j]=(char)b[j];
					}
				 return  new String(str).trim();
			} 
		  public static  byte[] stringToBytesCharset(String str,int len,String code) {   
			  ByteBuffer buffer = ByteBuffer.allocate(len);
			  try {
				return buffer.put(str.getBytes(code)).array();
			} catch (UnsupportedEncodingException e) {
				logger.info(e);
			}
			return new byte[0]; 
			} 
		  public static String bytesToStringCharset(byte[] b,String code) {   
			  try {
				return new String(b,code).trim();
			} catch (UnsupportedEncodingException e) {
				logger.info(e);
			}
			return null; 
			} 
		  public static byte[] stringsToBytesSUM(String[] str,int sumlen){
				byte[] bs2 = new byte[sumlen];
				int k=0;
				for(int j = 0;j<str.length;j++){
					  for(int i = 0; i < str[j].length(); i++) {
			    		  bs2[k++] = (byte) str[j].charAt(i);
			    	   }
				}
				return bs2;
			}
		  public static byte[] stringsToBytesAVG(String[] str,int avglen){
			byte[] bs2 = new byte[avglen*str.length];
			for(int j = 0;j<str.length;j++){
				  for(int i = 0; i < str[j].length(); i++) {
		    		  bs2[avglen*j+i] = (byte) str[j].charAt(i);
		    	   }
			}
			return bs2;
		   }
		  public static String[] bytesToStrings(byte[] b,int avglen){
			  String[] str = new String[b.length/avglen];
			    int k=0;
				for(int j = 0;j<b.length/avglen;j++){
					 str[j] = bytesToString(Arrays.copyOfRange(b,k,k+avglen));
					 k+=avglen;
				}
				return str;
			}
		  public static byte intToByte(int x) {  
			    return (byte) x;  
			}  
			public static int byteToInt(byte b) {  
			    return b & 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 byte[] intToBytes(int a) {   
			  return new byte[] {   
		          (byte) ((a >> 24) & 0xFF),   
		          (byte) ((a >> 16) & 0xFF),      
		          (byte) ((a >> 8) & 0xFF),      
		          (byte) (a & 0xFF)   
			      };   
			  }
		  public static int[] bytesToInts(byte[] b) {  
			  int [] bs2=new int[b.length/4];
			  for(int i=0;i<b.length/4;i++){
				  bs2[i]=b[i*4+3] & 0xFF | 
			      (b[i*4+2] & 0xFF) << 8 |   
	              (b[i*4+1] & 0xFF) << 16|   
	              (b[i*4] & 0xFF) << 24; 
			  }
			return bs2;
				  } 
		  public static byte[] intsToBytes(int[] a) { 
			  byte[] bs2=new byte[4*a.length];
			  int k=0;
			  for(int i=0;i<a.length;i++){
					  bs2[k++]=(byte) ((a[i] >> 24) & 0xFF);
					  bs2[k++]=(byte) ((a[i] >> 16) & 0xFF);
					  bs2[k++]=(byte) ((a[i] >> 8) & 0xFF);
					  bs2[k++]=(byte) (a[i] & 0xFF);
			  }
			return bs2;
		  }  
		   public static char byteToChar(byte bt) {  
		        return (char) bt;  
		    }  
		    public static byte charToByte(char ch) {  
		        return (byte) ch;  
		    }  
		    public static char[] bytesToChars(byte[] b) { 
		    	char[] bs2=new char[b.length];
		    	for(int i=0;i<b.length;i++){
		    		bs2[i]=(char)b[i];
		    	}
		        return bs2;  
		    }  
		    public static byte[] charsToBytes(char[] cs) {
		    	 byte[] bs2 = new byte[cs.length];
		    	  for(int i = 0; i < cs.length; i++) {
		    	   bs2[i] = (byte) cs[i];
		    	   }
				return bs2;
		    	 }
		    public static byte[] charToBytes(char ch) {  
		        byte[] bytes = new byte[2];  
		        bytes[0] = (byte) (ch >> 8 & 0xff);  
		        bytes[1] = (byte) (ch & 0xff);  
		        return bytes;  
		    }
		    public static char bytesToChar(byte[] b) {  
		        return (char) ((b[0] << 8 & 0xff00) | (b[1] & 0xff));  
		    } 
		    
		    public static byte shortToByte(short s) {  
		        return (byte) s;  
		    }
		    public static short byteToShort(byte b) {  
		        return (short) b;  
		    } 
		    public static byte[] shortToByteArray(short[] s) {  
		    	byte[] bs2 = new byte[s.length];
		    	  for(int i = 0; i < s.length; i++) {
		    	   bs2[i] = (byte) s[i];
		    	   }
				return bs2; 
		    }
		    public static short[] byteToShortArray(byte[] b) {  
		    	short[] bs2=new short[b.length];
		    	for(int i=0;i<b.length;i++){
		    		bs2[i]=(short)b[i];
		    	}
		        return bs2;    
		    } 
		    public static short bytesToShort(byte[] b) {  
		        short rt = 0;  
		        rt += (b[0] << 8 & 0xff00);  
		        rt += (b[1] & 0xff);  
		        return rt;  
		    }  
		    public static byte[] shortToBytes(short s) {  
		        byte[] bytes = new byte[2];  
		        bytes[0] = (byte) (s >> 8 & 0xff);  
		        bytes[1] = (byte) (s & 0xff);  
		        return bytes;  
		    } 
		    public static byte[] shorstToBytes(short[] a) { 
		    	  byte[] bs2=new byte[2*a.length];
				  int k=0;
				  for(int i=0;i<a.length;i++){
						  bs2[k++]=(byte) (a[i] >> 8 & 0xff);
						  bs2[k++]=(byte) (a[i] & 0xff);
				  }
				return bs2;
		    }
		    public static short[] bytesToShorts(byte[] b) {  
		    	short [] bs2=new short[b.length/2];
				  for(int i=0;i<b.length/2;i++){
					  bs2[i] += (b[i*2] << 8 & 0xff00);  
					  bs2[i] += (b[i*2+1] & 0xff);  
				  }
				return bs2;
		    } 
		    public static float bytesToFloat(byte[] b)
		    {
		      return Float.intBitsToFloat(bytesToInt(b));
		    }
		    public static byte[] floatTobytes(float f) {  
		        return intToBytes(Float.floatToIntBits(f));  
		    } 
		    public static float[] bytesToFloats(byte[] b)
		    {
		    	float [] bs2=new float[b.length/4];
			  for(int i=0;i<b.length/4;i++){
				  bs2[i]=Float.intBitsToFloat(b[i*4+3] & 0xFF | 
			      (b[i*4+2] & 0xFF) << 8 |   
	              (b[i*4+1] & 0xFF) << 16|   
	              (b[i*4] & 0xFF) << 24); 
			  }
			return bs2;
		    }
		    public static byte[] floatsTobytes(float[] a) {  
		    	  byte[] bs2=new byte[4*a.length];
				  int k=0;
				  for(int i=0;i<a.length;i++){
				  int kl=Float.floatToIntBits(a[i]);
				  bs2[k++]=(byte) ((kl >> 24) & 0xFF);
				  bs2[k++]=(byte) ((kl >> 16) & 0xFF);
				  bs2[k++]=(byte) ((kl >> 8) & 0xFF);
				  bs2[k++]=(byte) (kl & 0xFF);
				  }
				return bs2;  
		    } 
		    
		    public static byte[] doubleTobytes(double d) {  
		        return longToBytes(Double.doubleToLongBits(d));  
		    }  
		    public static double bytesToDouble(byte[] b) { 
		        long l; 
		        l = b[7]; 
		        l &= 0xff; 
		        l |= ((long) b[6] << 8); 
		        l &= 0xffff; 
		        l |= ((long) b[5] << 16); 
		        l &= 0xffffff; 
		        l |= ((long) b[4] << 24); 
		        l &= 0xffffffffl; 
		        l |= ((long) b[3] << 32); 
		        l &= 0xffffffffffl; 
		        l |= ((long) b[2] << 40); 
		        l &= 0xffffffffffffl; 
		        l |= ((long) b[1] << 48); 
		        l &= 0xffffffffffffffl; 
		        l |= ((long) b[0] << 56); 
		        return Double.longBitsToDouble(l); 
		    } 
		    public static byte[] doublesTobytes(double[] a) {  
		  	  byte[] bs2=new byte[8*a.length];
			  int k=0;
			  for(int i=0;i<a.length;i++){
			  long kl=Double.doubleToLongBits(a[i]);
			  bs2[k++] = (byte) (kl >>> 56);
			  bs2[k++] = (byte) (kl >>> 48);
			  bs2[k++] = (byte) (kl >>> 40);
			  bs2[k++] = (byte) (kl >>> 32);
			  bs2[k++] = (byte) (kl >>> 24);
			  bs2[k++] = (byte) (kl >>> 16);
			  bs2[k++] = (byte) (kl >>> 8); 
			  bs2[k++] = (byte) (kl); 
			  }
			return bs2; 
		    }  
		    public static double[] bytesToDoubles(byte[] b) { 
		    	double [] bs2=new double[b.length/8];
				  for(int i=0;i<b.length/8;i++){
					  long l; 
				        l = b[i*8+7]; 
				        l &= 0xff; 
				        l |= ((long) b[i*8+6] << 8); 
				        l &= 0xffff; 
				        l |= ((long) b[i*8+5] << 16); 
				        l &= 0xffffff; 
				        l |= ((long) b[i*8+4] << 24); 
				        l &= 0xffffffffl; 
				        l |= ((long) b[i*8+3] << 32); 
				        l &= 0xffffffffffl; 
				        l |= ((long) b[i*8+2] << 40); 
				        l &= 0xffffffffffffl; 
				        l |= ((long) b[i*8+1] << 48); 
				        l &= 0xffffffffffffffl; 
				        l |= ((long) b[i*8+0] << 56); 
					  bs2[i]=Double.longBitsToDouble(l);
				  }
				return bs2;
		    } 
		    public static long bytesToLong(byte[] b) {  
    	        return (((long) b[0] & 0xff) << 56)  
	             | (((long) b[1] & 0xff) << 48)  
	             | (((long) b[2] & 0xff) << 40)  
	             | (((long) b[3] & 0xff) << 32)  
	             | (((long) b[4] & 0xff) << 24)  
	             | (((long) b[5] & 0xff) << 16)  
	             | (((long) b[6] & 0xff) << 8)  
	             |  ((long) b[7] & 0xff);  
		    	}
		    public static byte[] longToBytes(long num) {
		    	  byte[] result = new byte[8];
		    	  result[0] = (byte) (num >>> 56);
		    	  result[1] = (byte) (num >>> 48);
		    	  result[2] = (byte) (num >>> 40);
		    	  result[3] = (byte) (num >>> 32);
		    	  result[4] = (byte) (num >>> 24);
		    	  result[5] = (byte) (num >>> 16);
		    	  result[6] = (byte) (num >>> 8); 
		    	  result[7] = (byte) (num); 
		    	  return result;
		    	 }
		    public static long[] bytesToLongs(byte[] b) {  
		    	long [] bs2=new long[b.length/8];
			  for(int i=0;i<b.length/8;i++){
				  bs2[i]=(((long) b[i*8+0] & 0xff) << 56)  
	             | (((long) b[i*8+1] & 0xff) << 48)  
	             | (((long) b[i*8+2] & 0xff) << 40)  
	             | (((long) b[i*8+3] & 0xff) << 32)  
	             | (((long) b[i*8+4] & 0xff) << 24)  
	             | (((long) b[i*8+5] & 0xff) << 16)  
	             | (((long) b[i*8+6] & 0xff) << 8)  
	             |  ((long) b[i*8+7] & 0xff);   
			  }
			return bs2;
		    	}
		    public static byte[] longsToBytes(long[] num) {
		    	  byte[] bs2=new byte[8*num.length];
				  int k=0;
				  for(int i=0;i<num.length;i++){
					  bs2[k++] = (byte) (num[i] >>> 56);
					  bs2[k++] = (byte) (num[i] >>> 48);
					  bs2[k++] = (byte) (num[i] >>> 40);
					  bs2[k++] = (byte) (num[i] >>> 32);
					  bs2[k++] = (byte) (num[i] >>> 24);
					  bs2[k++] = (byte) (num[i] >>> 16);
					  bs2[k++] = (byte) (num[i] >>> 8); 
					  bs2[k++] = (byte) (num[i]); 
				  }
				return bs2;
		    	 }
		    
		    public static byte booleanToByte(boolean b) {
		    	  return (byte) (b ? 0x01 : 0x00);
		    	 }
		    public static boolean byteToBoolean(byte b) {
		    	  return (b == 0x00) ? false : true;
		    	 }
		    public static byte[] booleansToByte(boolean[] s) {
		    	byte[] bs2 = new byte[s.length];
		    	  for(int i = 0; i < s.length; i++) {
		    	   bs2[i] = (byte) (s[i]? 0x01 : 0x00);
		    	   }
				return bs2; 
		    	 }
		    public static boolean[] byteToBooleans(byte[] b) {
		    	boolean[] bs2=new boolean[b.length];
		    	for(int i=0;i<b.length;i++){
		    		bs2[i]=(b[i] == 0x00) ? false : true;
		    	}
		        return bs2;  
		    	 }
}