如何以最高精度格式化double类型数值？

方法1：使用内部API（不推荐生产环境） #

Java的内部类sun.misc.FloatingDecimal可以直接获取double的精确十进制字符串，效果和new BigDecimal(double).toString()完全一致：

import sun.misc.FloatingDecimal;

public class Main {
    public static void main(String[] args) {
        double num = 0.1;
        FloatingDecimal fd = FloatingDecimal.getDoubleInstance(num);
        String exactString = fd.toJavaFormatString();
        System.out.println(exactString); 
        // 输出：0.1000000000000000055511151231257827021181583404541015625
    }
}

注意：这是未公开的内部API，可能在Java不同版本中被修改或移除，仅适合临时测试场景。

方法2：手动解析double的二进制结构（推荐，无依赖） #

double遵循IEEE 754标准存储，由符号位、指数位、尾数位组成。我们可以解析这些部分，通过BigInteger（不属于BigDecimal范畴）计算精确十进制值：

import java.math.BigInteger;

public class DoubleExactString {
    public static String toExactString(double d) {
        // 处理0值
        if (d == 0.0) {
            return Double.isNegativeZero(d) ? "-0.0" : "0.0";
        }

        // 获取double的二进制位表示
        long bits = Double.doubleToLongBits(d);
        boolean negative = (bits >> 63) != 0;
        int exponent = (int)((bits >> 52) & 0x7FFL);
        long mantissa = bits & 0xFFFFFFFFFFFFFL;

        // 处理特殊值：无穷大、NaN
        if (exponent == 0x7FF) {
            return mantissa != 0 ? "NaN" : (negative ? "-Infinity" : "Infinity");
        }

        // 计算有效数字：规格化数的尾数前隐含一个1
        BigInteger significand = BigInteger.ONE.shiftLeft(52).add(BigInteger.valueOf(mantissa));
        // 计算指数偏移（IEEE 754偏置值为1023）
        int exp = exponent - 1023;

        // 转换为分数形式：significand * 2^(exp - 52)
        BigInteger numerator = significand;
        BigInteger denominator = BigInteger.ONE;

        if (exp >= 52) {
            numerator = numerator.shiftLeft(exp - 52);
        } else {
            denominator = denominator.shiftLeft(52 - exp);
        }

        // 约分分数
        BigInteger gcd = numerator.gcd(denominator);
        numerator = numerator.divide(gcd);
        denominator = denominator.divide(gcd);

        // 拼接十进制字符串
        StringBuilder sb = new StringBuilder(negative ? "-" : "");
        sb.append(numerator.divide(denominator));
        if (denominator.equals(BigInteger.ONE)) {
            return sb.toString();
        }
        sb.append('.');

        // 计算小数部分
        BigInteger remainder = numerator.mod(denominator);
        while (!remainder.equals(BigInteger.ZERO)) {
            remainder = remainder.multiply(BigInteger.TEN);
            sb.append(remainder.divide(denominator));
            remainder = remainder.mod(denominator);
        }

        return sb.toString();
    }

    public static void main(String[] args) {
        System.out.println(toExactString(0.1));
        // 输出：0.1000000000000000055511151231257827021181583404541015625
    }
}

该方法完全基于JDK标准类实现，稳定性高，适合生产环境使用。

内容的提问来源于stack exchange，提问作者k314159