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

Question

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

Answer 1

"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);
    }

Answer 2

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

Answer 3

附上那个字符串反转的方法：    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);
    }

Answer 4

楼上的回答很不错。其实只要理解了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

Answer 5

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)); }