Java 数据类型转换

  1. package common.util;  
  2.   
  3. /** 
  4.  * 对数字和字节进行转换。<br> 
  5.  * 基础知识：<br> 
  6.  * 假设数据存储是以大端模式存储的：<br> 
  7.  * byte: 字节类型 占8位二进制 00000000<br> 
  8.  * char: 字符类型 占2个字节 16位二进制 byte[0] byte[1]<br> 
  9.  * int : 整数类型 占4个字节 32位二进制 byte[0] byte[1] byte[2] byte[3]<br> 
  10.  * long: 长整数类型 占8个字节 64位二进制 byte[0] byte[1] byte[2] byte[3] byte[4] byte[5] 
  11.  * byte[6] byte[7]<br> 
  12.  * float: 浮点数(小数) 占4个字节 32位二进制 byte[0] byte[1] byte[2] byte[3]<br> 
  13.  * double: 双精度浮点数(小数) 占8个字节 64位二进制 byte[0] byte[1] byte[2] byte[3] byte[4] 
  14.  * byte[5] byte[6] byte[7]<br> 
  15.  */  
  16. public class NumberBytes {  
  17.   
  18.     /** 
  19.      * 将一个2位字节数组转换为char字符。<br> 
  20.      * 注意，函数中不会对字节数组长度进行判断，请自行保证传入参数的正确性。 
  21.      *  
  22.      * @param b 
  23.      *            字节数组 
  24.      * @return char字符 
  25.      */  
  26.     public static char bytesToChar(byte[] b) {  
  27.         char c = (char) ((b[0] << 8) & 0xFF00L);  
  28.         c |= (char) (b[1] & 0xFFL);  
  29.         return c;  
  30.     }  
  31.   
  32.     /** 
  33.      * 将一个8位字节数组转换为双精度浮点数。<br> 
  34.      * 注意，函数中不会对字节数组长度进行判断，请自行保证传入参数的正确性。 
  35.      *  
  36.      * @param b 
  37.      *            字节数组 
  38.      * @return 双精度浮点数 
  39.      */  
  40.     public static double bytesToDouble(byte[] b) {  
  41.         return Double.longBitsToDouble(bytesToLong(b));  
  42.     }  
  43.   
  44.     /** 
  45.      * 将一个4位字节数组转换为浮点数。<br> 
  46.      * 注意，函数中不会对字节数组长度进行判断，请自行保证传入参数的正确性。 
  47.      *  
  48.      * @param b 
  49.      *            字节数组 
  50.      * @return 浮点数 
  51.      */  
  52.     public static float bytesToFloat(byte[] b) {  
  53.         return Float.intBitsToFloat(bytesToInt(b));  
  54.     }  
  55.   
  56.     /** 
  57.      * 将一个4位字节数组转换为4整数。<br> 
  58.      * 注意，函数中不会对字节数组长度进行判断，请自行保证传入参数的正确性。 
  59.      *  
  60.      * @param b 
  61.      *            字节数组 
  62.      * @return 整数 
  63.      */  
  64.     public static int bytesToInt(byte[] b) {  
  65.         int i = (b[0] << 24) & 0xFF000000;  
  66.         i |= (b[1] << 16) & 0xFF0000;  
  67.         i |= (b[2] << 8) & 0xFF00;  
  68.         i |= b[3] & 0xFF;  
  69.         return i;  
  70.     }  
  71.   
  72.     /** 
  73.      * 将一个8位字节数组转换为长整数。<br> 
  74.      * 注意，函数中不会对字节数组长度进行判断，请自行保证传入参数的正确性。 
  75.      *  
  76.      * @param b 
  77.      *            字节数组 
  78.      * @return 长整数 
  79.      */  
  80.     public static long bytesToLong(byte[] b) {  
  81.         long l = ((long) b[0] << 56) & 0xFF00000000000000L;  
  82.         // 如果不强制转换为long，那么默认会当作int，导致最高32位丢失  
  83.         l |= ((long) b[1] << 48) & 0xFF000000000000L;  
  84.         l |= ((long) b[2] << 40) & 0xFF0000000000L;  
  85.         l |= ((long) b[3] << 32) & 0xFF00000000L;  
  86.         l |= ((long) b[4] << 24) & 0xFF000000L;  
  87.         l |= ((long) b[5] << 16) & 0xFF0000L;  
  88.         l |= ((long) b[6] << 8) & 0xFF00L;  
  89.         l |= (long) b[7] & 0xFFL;  
  90.         return l;  
  91.     }  
  92.   
  93.     /** 
  94.      * 将一个char字符转换位字节数组（2个字节），b[0]存储高位字符，大端 
  95.      *  
  96.      * @param c 
  97.      *            字符（java char 2个字节） 
  98.      * @return 代表字符的字节数组 
  99.      */  
  100.     public static byte[] charToBytes(char c) {  
  101.         byte[] b = new byte[8];  
  102.         b[0] = (byte) (c >>> 8);  
  103.         b[1] = (byte) c;  
  104.         return b;  
  105.     }  
  106.   
  107.     /** 
  108.      * 将一个双精度浮点数转换位字节数组（8个字节），b[0]存储高位字符，大端 
  109.      *  
  110.      * @param d 
  111.      *            双精度浮点数 
  112.      * @return 代表双精度浮点数的字节数组 
  113.      */  
  114.     public static byte[] doubleToBytes(double d) {  
  115.         return longToBytes(Double.doubleToLongBits(d));  
  116.     }  
  117.   
  118.     /** 
  119.      * 将一个浮点数转换为字节数组（4个字节），b[0]存储高位字符，大端 
  120.      *  
  121.      * @param f 
  122.      *            浮点数 
  123.      * @return 代表浮点数的字节数组 
  124.      */  
  125.     public static byte[] floatToBytes(float f) {  
  126.         return intToBytes(Float.floatToIntBits(f));  
  127.     }  
  128.   
  129.     /** 
  130.      * 将一个整数转换位字节数组(4个字节)，b[0]存储高位字符，大端 
  131.      *  
  132.      * @param i 
  133.      *            整数 
  134.      * @return 代表整数的字节数组 
  135.      */  
  136.     public static byte[] intToBytes(int i) {  
  137.         byte[] b = new byte[4];  
  138.         b[0] = (byte) (i >>> 24);  
  139.         b[1] = (byte) (i >>> 16);  
  140.         b[2] = (byte) (i >>> 8);  
  141.         b[3] = (byte) i;  
  142.         return b;  
  143.     }  
  144.   
  145.     /** 
  146.      * 将一个长整数转换位字节数组(8个字节)，b[0]存储高位字符，大端 
  147.      *  
  148.      * @param l 
  149.      *            长整数 
  150.      * @return 代表长整数的字节数组 
  151.      */  
  152.     public static byte[] longToBytes(long l) {  
  153.         byte[] b = new byte[8];  
  154.         b[0] = (byte) (l >>> 56);  
  155.         b[1] = (byte) (l >>> 48);  
  156.         b[2] = (byte) (l >>> 40);  
  157.         b[3] = (byte) (l >>> 32);  
  158.         b[4] = (byte) (l >>> 24);  
  159.         b[5] = (byte) (l >>> 16);  
  160.         b[6] = (byte) (l >>> 8);  
  161.         b[7] = (byte) (l);  
  162.         return b;  
  163.     }  
  164.   
  165. } 
posted @ 2016-07-21 15:52  dghwey  阅读(250)  评论(0)  编辑  收藏  举报