Java 中floatdouble在内存中的存储格式及数据的获取

浮点数保存的字节格式如下：

地址 +0 +1 +2 +3
内容 SEEE EEEE EMMM MMMM MMMM MMMM MMMM MMMM

这里
S 代表符号位，1是负，0是正
E 偏移127的幂，二进制阶码=(EEEEEEEE)-127。
M 24位的尾数保存在23位中，只存储23位，最高位固定为1。此方法用最较少的位数实现了
较高的有效位数，提高了精度。

零是一个特定值，幂是0 尾数也是0。

浮点数-12.5作为一个十六进制数0xC1480000保存在存储区中，这个值如下：
地址 +0 +1 +2 +3
内容0xC1 0x48 0x00 0x00

浮点数和十六进制等效保存值之间的转换相当简单。下面的例子说明上面的值-12.5如何转
换。
浮点保存值不是一个直接的格式，要转换为一个浮点数，位必须按上面的浮点数保存格式表
所列的那样分开，例如：

地址 +0 +1 +2 +3
格式 SEEE EEEE EMMM MMMM MMMM MMMM MMMM MMMM
二进制 11000001 01001000 00000000 00000000
十六进制 C1 48 00 00

从这个例子可以得到下面的信息：
符号位是1 表示一个负数
幂是二进制10000010或十进制130，130减去127是3，就是实际的幂。
尾数是后面的二进制数10010000000000000000000

在尾数的左边有一个省略的小数点和1,这个1在浮点数的保存中经常省略,加上一个1和小数
点到尾数的开头,得到尾数值如下:
1.10010000000000000000000

接着,根据指数调整尾数.一个负的指数向左移动小数点.一个正的指数向右移动小数点.因为
指数是3,尾数调整如下:
1100.10000000000000000000

结果是一个二进制浮点数，小数点左边的二进制数代表所处位置的2的幂，例如：1100表示
(1*2^3)+(1*2^2)+(0*2^1)+(0*2^0)=12。
小数点的右边也代表所处位置的2的幂，只是幂是负的。例如：.100...表示(1*2^(-1))+
(0*2^(-2))+(0*2^(-2))...=0.5。
这些值的和是12.5。因为设置的符号位表示这数是负的，因此十六进制值0xC1480000表示-
12.5。

关于多字节数据类型在内存中的存储问题

int ,short 分别是4、2字节。他们在内存中的存储方式下面举个例子说明。

int data = 0xf4f3f2f1;
其中低位存放在编址小的内存单元，高位存放在编址高的内存单元
如下：
地址：0x8000 0x8001 0x8002 0x8003
数据： f1 f2 f3 f4

根据IEEE在1985年制定的标准来处理浮点数
单精度浮点数用4字节，包括1位符号位s(整数为0，负数为1)，8位指数位e，23位有效位f
浮点型使用的是科学计数法，比如十进制的12345可以表示为1.2345 * 10^4(表示10的4次幂)
用二进制表示为 1.1000000111001 * 2^13
所以计算机中用浮点数表示12345这个十进制应该是这样的，s位为0，因为是正数，指数位为13+127=140(127为单精度浮点数偏移值，为了表示只有小数部分的数)，有效位为1000000111001
计算的时候用 (-1)^s * 1.f * 2^(e-127) ，结果就是 1* 1.1000000111001 * 2^(140-127=13) ，和我们刚才表示的一样
还比如，十进制小数0.125转换为二进制小数0.001可以表示为 1* 1.0 * 2^(124-127=-3)
double，双精度浮点数有1位符号位、11位指数位和52位有效数

谢谢，和我找的资料差不多：）
知道公式
n=(-1)^s*m*2^e
e=|E|-bias
bias = 2^(k-1)-1(k为E的位数）
m=|1.M|


知道12345在内存中的10进制表示以后
0x4640e400 = 0(100 0110 0)<100 0000 1110 0100 0000>
括号中的数字为|E| ＝ 140 所以e＝140－127＝13
尖括号中的数字为m=|1.M|＝｜1.100000011100100｜＝1.506958008
ok,
代入公式n = (-1)^0*1.506958008*2^13=12345

下面附上自己写的数据转换工具类：

package com.zhcw.tools;
import java.text.DecimalFormat;

public class DataUtil {
private final static char[] HEX = "0123456789abcdef".toCharArray();

/**
* 将 int 类型数据转成二进制的字符串，不足 int 类型位数时在前面添“0”以凑足位数
*
* @param num
* @return
*/
@SuppressWarnings("unused")
private static String toFullBinaryString(int num) {
char[] chs = new char[Integer.SIZE];
for (int i = 0; i < Integer.SIZE; i++) {
chs[Integer.SIZE - 1 - i] = (char) (((num >> i) & 1) + '0');
}
return new String(chs);
}

/**datautil
* 将 int 类型数据转成十六进制的字符串，不足 int 类型位数时在前面添“0”以凑足位数
*
* @param num
* @return
*/
@SuppressWarnings("unused")
private static String toFullHexString(int num) {
char[] chs = new char[Integer.SIZE / 4];
for (int i = 0; i < chs.length; i++) {
chs[chs.length - 1 - i] = HEX[(num >> (i * 4)) & 0xf];
}
return new String(chs);
}

/**
* 将 long 类型数据转成二进制的字符串，不足 long 类型位数时在前面添“0”以凑足位数
*
* @param num
* @return
*/
@SuppressWarnings("unused")
private static String toFullBinaryString(long num) {
char[] chs = new char[Long.SIZE];
for (int i = 0; i < Long.SIZE; i++) {
chs[Long.SIZE - 1 - i] = (char) (((num >> i) & 1) + '0');
}
return new String(chs);
}

/**
* 将 long 类型数据转成十六进制的字符串，不足 long 类型位数时在前面添“0”以凑足位数
*
* @param num
* @return
*/
@SuppressWarnings("unused")
private static String toFullHexString(long num) {
char[] chs = new char[Long.SIZE / 4];
for (int i = 0; i < chs.length; i++) {
chs[chs.length - 1 - i] = HEX[(int) ((num >> (i * 4)) & 0xf)];
}
return new String(chs);
}

/**
* @param args
*/
public static String GetDoubleNum(String hexString) {
String str = hexString;
int index;
int sym;
double result;
byte[] SteByte2 = null;
String Byte2String = convertHexToBinary3(str);
index = GetIndex(Byte2String);
sym = GetSymbol(Byte2String);
System.out.println("sym->" + sym);
SteByte2 = GetByte2buf(Byte2String);
result = GetIntNum(SteByte2, index) * sym;
System.out.println("result->" + result / 100);
DecimalFormat df = new DecimalFormat("###0");// 最多保存几位小数，就用几个#，最少位就用0来确定
String s = df.format(result / 100);
System.out.println("result->" + s);
return s;

}

/***
*浮点数保存的字节格式如下：float 地址 +0 +1 +2 +3 内容 SEEE EEEE EMMM MMMM MMMM MMMM MMMM
* MMMM 浮点数保存的字节格式如下：double n=(-1)^s*m*2^e e=|E|-bias bias =
* 2^(k-1)-1(k为E的位数） m=|1.M|
*/

@SuppressWarnings("unused")
private String getLongBits(long a) {
// 8个字节的字节数组,读出来
System.out.println("getLongBits");
byte[] b = new byte[8];
for (int i = 7; i >= 0; i--) {
b[i] = (byte) (a & 0x000000FF);
a = a >> 8;
}
System.out.println("over");
return byte2hex(b); // 调用下面一个函数
}

/**
* 将byte数组转换成十六进制的字符串
*
* @param b
* @return String
*/
private static String byte2hex(byte[] b) {

System.out.println("byte2hex");
StringBuffer sb = new StringBuffer();
String stmp = "";
for (int n = 0; n < b.length; n++) {
stmp = (Integer.toHexString(b[n] & 0XFF));
if (stmp.length() == 1) {
// 不足两位的末尾补零
sb.append("0" + stmp);
} else {
sb.append(stmp);
}
if (sb.length() % 2 == 0)// ":"作为分割符
sb.append(":");
System.out.println("byte2hex over->" + n);
}
System.out.println("byte2hex over");
return sb.toString().toUpperCase();
}

/**
* 将十六进制的字符串转换成二进制字符串
*
* @param hexString
* @return String
*/
private static String convertHexToBinary3(String hexString) {
long l = Long.parseLong(hexString, 16);
String binaryString = Long.toBinaryString(l);
int shouldBinaryLen = hexString.length() * 4;
StringBuffer addZero = new StringBuffer();
int addZeroNum = shouldBinaryLen - binaryString.length();
for (int i = 1; i <= addZeroNum; i++) {
addZero.append("0");
}
System.out.println("convertHexToBinary3->" + addZero.toString()
+ binaryString);
return addZero.toString() + binaryString;

}

/**
* 从二进制字符串的1-12位中得到指数
*
* @param str
* @return int
*/
private static int GetIndex(String str) {
String index_str = "";
int index_int;
int base_index = (int) java.lang.Math.pow(2, 10) - 1;
System.out.println("base_index->" + base_index);
index_str = str.substring(1, 12);
System.out.println("index_str->" + index_str);
index_int = Integer.valueOf(index_str, 2) - base_index;
System.out.println("GetIndex->" + index_int);
return index_int;
}

/**
* 从第一位判断符号位
*
* @param str
* @return int
*/
private static int GetSymbol(String str) {
System.out.println("GetSymbol->" + str.charAt(0));
if (str.charAt(0) == 48)
return 1;
else
return -1;
}

/**
* 从二进制字符串中得到M位，放到byte数组中返回
*
* @param str
* @return byte[]
*/
private static byte[] GetByte2buf(String str) {
String strM = "";
byte[] SteByte2 = new byte[str.length() + 1];
System.out.println("SteByte2->" + str.length());
strM = str.substring(12, 63);
strM = "1".concat(strM);
for (byte i = 0; i < strM.length(); i++)
SteByte2[i] = (byte) strM.charAt(i);
System.out.println("strM->" + strM);
return SteByte2;
}
/**
* 根据传入的参数M位和指数大小算出十进制数
* @param byte[] bytebuf, int index
* @return double
*/
public static double GetIntNum(byte[] bytebuf, int index) {
double sum = 0;
int tmp = -1;
for (byte i = 0; i < bytebuf.length && index >= 0; i++, index--) {
if (bytebuf[i] == 49) {
tmp = 1;
} else
tmp = 0;
sum += tmp * java.lang.Math.pow(2, index);
}
System.out.println("sum->" + sum);
return sum;
}
}