如何在 Java 中将 IEEE-754 二进制表示字符串转换为浮点数或双精度数?

Question

由于所有 Java 浮点数(浮点数和双精度数)在内部表示为位，因此我想找到一种有效的算法来转换表示该浮点数或双精度数位的 String 并将其转换为相应的浮点数- 我找不到它的内置库函数，所以我求助于自己编写它。

长度为 32 的二进制字符串表示浮点数，其中长度为 64 的二进制字符串将转换为双精度值。所有浮点数都可以转换为双精度，而不会损失精度。空格将被忽略。

例子

• "0 10000000 10010010000111111011011"变得像浮子一样3.141592。
• "1 11111111 00000000000000000000000"变得-infinity.
• "0 11111111 10010010000111111011011"成为浮子NaN。
• 
  "1 10000000000 0101101111110000101010001011000101000101011101101001"成为最接近-e的双精度值，即2.71828182845904509079559829843

到目前为止，我有这么多代码：

public static double ieee(String binString) throws Exception {
binString = binString.replace(" ", "");
if (binString.length() == 32) {
String exponentB = binString.substring(1, 9);
String mantissaB = binString.substring(9, 32);
int sgn = binString.charAt(0) == '0' ? 1 : -1;
int exponent = Integer.parseInt(exponentB, 2) - 127; // Biased by 127
double mantissa = 1 + Integer.parseInt(mantissaB, 2) / Math.pow(2, 23);
if (exponent == 128 && mantissa == 1)
return sgn == 1 ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY;
if (exponent == 128 && mantissa != 0)
return Double.NaN;
if (exponent == -127)
return sgn*Math.pow(2,-126)*(mantissa - 1);
return sgn*Math.pow(2, exponent)*mantissa;
}
else if (binString.length() == 64) {
String exponentB = binString.substring(1, 12);
String mantissaB = binString.substring(12, 64);
int sgn = binString.charAt(0) == '0' ? 1 : -1;
int exponent = Integer.parseInt(exponentB, 2) - 1023; // Biased by 1023
double mantissa = 1 + Long.parseLong(mantissaB, 2) / Math.pow(2, 52);
if (exponent == 1024 && mantissa == 1)
return sgn == 1 ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY;
if (exponent == 1024 && mantissa != 0)
return Double.NaN;
if (exponent == -1023)
return sgn*Math.pow(2,-1022)*(mantissa - 1);
return sgn*Math.pow(2, exponent)*mantissa;
}
else {
throw new Exception("Does not represent internal bits of a floating-point number");
}
}

虽然我的代码到目前为止可以工作，但就代码速度和数量而言，将 IEEE-754 二进制表示字符串转换为其float或double的最整洁或最快的方法是什么？最好是最有效的方法，并对其效率和专业知识进行很好的解释。

Answer 1

这种方法可能更有效。 它当然更简单，更易于维护。

1. 从字符串中删除空格
2. 验证字符串长度...
3. 将二进制字符串转换为int
4. 调用Float.intBitsToFloat(int)转换为float。

对于双打，请使用long和等效的Double方法。

---

简化的代码是否更有效率？

确定的唯一方法是对其进行基准测试。 但是根据你的代码正在做的事情，我相信是这样。

Answer 2

从@StephenC开始，将IEEE-754二进制表示转换为其相应的浮点值的改进代码仅占用一行：

return Float.intBitsToFloat(Integer.parseUnsignedInt(binString, 2));

• Integer.parseUnsignedInt(binString, 2)将二进制数字中的无符号int 从范围 0 转换为 2^32-1的int表示形式。parseInt(...)不起作用，因为它parseIntbinString中涉及一个明确的符号，如果它表示负整数，则需要前导连字符而不是 2³¹或更大的值。同样，Long.parseUnsignedLong(binString, 2)适用于 64 位情况。

• Float.intBitsToFloat(int n)表示浮点值，其内部存储的位与 int 值n相同。同样，Double.longBitsToDouble(long n)适用于 64 位情况。

• 使用"方法组合"，此行首先将(无符号)二进制字符串转换为其相应的 int，然后将其转换为具有相同存储位的浮点值。

最终代码将是

public static double ieeeToFloat(String binString) throws Exception {
binString = binString.replace(" ", "");
/* 32-bit */
if (binString.length() == 32) {
return Float.intBitsToFloat(Integer.parseUnsignedInt(binString, 2));
}
/* 64-bit */
else if (binString.length() == 64) {
return Double.longBitsToDouble(Long.parseUnsignedLong(binString, 2));
}
/* An exception thrown for mismatched strings */
else {
throw new Exception("Does not represent internal bits of a floating-point number");
}
}

Answer 3

public class IEEE754ToFloatingValues {
public static double convertToInt(String mantissa_str) {

int power_count = -1;
double mantissa_int = 0.0;
for (int i = 0; i < mantissa_str.length(); i++) {
// System.out.print(Integer.parseInt(mantissa_str.charAt(i) + ""));
mantissa_int += (Integer.parseInt(mantissa_str.charAt(i) + "") * Math.pow(2, power_count));
power_count -= 1;
}
return mantissa_int + 1.0;
}
public static String convertToBinary(int i) {

return Integer.toBinaryString(i + 0b10000).substring(1);
}
public static String decimalToHex(String decimal) {
int i = Integer.parseInt(decimal);
System.out.println("<<>>" + i);
String my_hexdata = Integer.toHexString(i);
System.out.println(my_hexdata);
return String.valueOf(ReturnFloatingValue(my_hexdata));
}
public static double ReturnFloatingValue(String my_hexdata) {
String myString = "";
if (my_hexdata == null) {
return -2.0;
}
if (my_hexdata.length() != 8) {
myString = String.format("%1$-" + 8 + "s", my_hexdata).replace(' ', '0');
System.out.println("My hex data after appending 0's is : " + myString);
}
String binary = "";
for (int i = 0; i < myString.length(); i++) {
int num = Integer.parseInt(myString.charAt(i) + "", 16);
binary += convertToBinary(num);
}
System.out.println("Binary length is :  " + binary.length());
System.out.println("Binary number is : " + binary);
if (binary == null || binary.isEmpty()) {
return -3.0;
}
String ieee_32 = binary.substring(2);
ieee_32 = String.format("%1$-32s", binary).replace(' ', '0');
long sign_bit = Long.parseLong(new StringBuilder().append(ieee_32.charAt(0)).toString());
long exponent_bias = Long.parseLong(ieee_32.substring(1, 9), 2);
long exponent_unbias = exponent_bias - 127L;
System.out.println("Exponent unbias is  : " + exponent_unbias);
String mantissa_str = ieee_32.substring(9);
double mantissa_int = convertToInt(mantissa_str);
double real_no = Math.pow(-1.0, (double) sign_bit) * mantissa_int * Math.pow(2.0, (double) exponent_unbias);
System.out.println("Real no is : " + real_no);
return real_no;
}
public static void main(String[] args) {
//decimalToHex("16547");
}
}