java 浮点数转换 百分求解，今晚结贴！

[revoinfo]

如上图所示, 42 60 b9 41 如何颠倒后，再转换成十进制的 23.172001 又该如何转换成 二进制呐？
请j2se高手亮招！

[wangfeiwoyun]

"4260b941", 转成"41b96042" 我想应该不难吧。

/*用十六进制的"41b96042"，转成一个十进制整数(这个十进制数并不是浮点数)：*/
  int intValue= Integer.parseInt(str, 16);
/*然后用这个十进制整数得到一个二进制字符串：*/
  //结果就是：100 0001 1011 1001 0110 0000 0100 0010
  String binaryString = Integer.toBinaryString(intValue); 

取到这个2进制数，然后将这个2进制数转成float

    //这里只处理规格化数，非规格化数，NaN，finite等没有考虑
    static float binaryStringToFloat(final String binaryString) {
        // float是32位，将这个binaryString左边补0补足32位，如果是Double补足64位。
    	final String stringValue = leftPad(binaryString, '0', 32);
    	
    	// 首位是符号部分，占1位。
    	// 如果符号位是0则代表正数，1代表负数
    	final int sign = stringValue.charAt(0) == '0' ? 1 : -1;
    	
    	// 第2到9位是指数部分，float占8位，double占11位。
    	final String exponentStr = stringValue.substring(1, 9);
    	
    	// 将这个二进制字符串转成整数，由于指数部分加了偏移量（float偏移量是127，double是1023）
        // 所以实际值要减去127
    	final int exponent = Integer.parseInt(exponentStr, 2) - 127;
    	
    	// 最后的23位是尾数部分，由于规格化数，小数点左边隐含一个1，现在加上
    	final String mantissaStr = "1".concat(stringValue.substring(9, 32));
        //这里用double，尽量保持精度，最好用BigDecimal，这里只是方便计算所以用double
    	double mantissa = 0.0;
    	
    	for(int i = 0; i < mantissaStr.length(); i++) {
    		final int intValue = Character.getNumericValue(mantissaStr.charAt(i));
    		//计算小数部分，具体请查阅二进制小数转10进制数相关资料
    		mantissa += (intValue * Math.pow(2, -i));
    	}
        // 根据IEEE 754 标准计算：符号位 * 2的指数次方 * 尾数部分
    	return (float)(sign * Math.pow(2, exponent) * mantissa);
    }

    // 一个简单的补齐方法，很简单，没考虑很周到。具体请参考common-long.jar/StringUtils.leftPad()
    static String leftPad(final String str, final char padChar, int length) {
    	final int repeat = length - str.length();
    	
    	if(repeat <= 0) {
    		return str;
    	}
    	
        final char[] buf = new char[repeat];
        for (int i = 0; i < buf.length; i++) {
            buf[i] = padChar;
        }
        return new String(buf).concat(str);
    }

[wangfeiwoyun]

有个错误：应该是commons-lang.jar，不是commons-long.jar.
老是把lang写成long

[wangfeiwoyun]

附上那个字符串反转的方法：

    static String reverse8BitsHexString(final String source) {
    	final int length = source.length();
    	
    	final char[] result = new char[length];
    	
    	for(int i = length - 1; i > 0; i = i - 2) {
    		result[length - i - 1] = source.charAt(i - 1);
    		result[length - i] = source.charAt(i);
    	}
    	
    	return new String(result);
    }

[Jaya1989]

楼上的回答很不错。

其实只要理解了float的存储方式，计算起来就不难。

float内存存储结构(共4字节，32位分别如下)：
31 30 29----23 22----0

实数符号位 指数符号位 指数位 有效数位
其中实数符号位0表示正，1表示负；指数符号位1表示正，0表示负

float在计算机中的存储计算方法：
1. 先将这个实数的绝对值化为二进制格式，方法是：实数的整数部分是除2取余和小数部分是乘2取整
2. 将这个二进制格式实数的小数点左移或右移n位，直到小数点移动到第一个有效数字的右边。
3. 从小数点右边第一位开始数出二十三位数字放入第22到第0位。
4. 如果实数是正的，则在第31位放入“0”，否则放入“1”。
5. 如果n 是左移得到的，说明指数是正的，第30位放入“1”。如果n是右移得到的或n=0，则第30位放入“0”。
6. 如果n是左移得到的，则将n减去1后化为二进制，并在左边加“0”补足七位，放入第29到第23位。如果n是右移得到的或n=0，

则将n化为二进制后在左边加“0”补足七位，再各位求反，再放入第29到第23位。

根据上面那个步骤得：
(1). 23.172001二进制形式为：0001,0111.0010,1100,0000,1000,0100,0001....
(2)左移4位得：1.0111.0010,1100,0000,1000,0100,0001
(3)取小数点后23位得： 0111.0010,1100,0000,1000,010（这23位为float数二进制码的后23位）
(4)第31位： 0
(5)第30位： 1
(6)左移4位，4的二进制0011，不足7位则：0000,011
最后得23.172001在计算机中的二进制表现形式为：0100,0001,1011,1001,0110,0000,0100,0010
二进制转16进制得：41A96042

[Jaya1989]

(6)左移4位，4的二进制0011，不足7位则：0000,011
这句写错了，是(6)左移4位，(4-1)的二进制0011，不足7位则：0000,011

[revoinfo]

非常抱歉，昨晚有事，没来得及上.

[yktd26]

	public static void main(String[] args) {
		String input = "4260b941";
		
		int n = Integer.reverseBytes(Integer.parseInt(input, 16));				
		float f = Float.intBitsToFloat(n);
		
		System.out.println(f);
		System.out.println(Integer.toBinaryString(n));

	}