如何提取double/float类型数值的无小数点小数部分并转为整数

嘿，我来帮你搞定这个问题！首先得明确一个关键细节：像Java里的int这类整数类型本身是不存储前导零的——比如你想要的0131作为int变量存储的话，实际值就是131，前导零只能在输出的时候通过格式化来实现。接下来我给你两种靠谱的解决方案，适配不同的场景：

这种方法通过将数值转成字符串来分割提取小数部分，能完美保留包括前导零在内的所有数字，还能避免浮点数精度带来的误差，是最稳妥的选择。

实现步骤： #

1. 用DecimalFormat将double/float转成普通字符串格式，避免触发科学计数法（比如极小/极大数可能自动转科学计数）；
2. 以小数点为分隔符拆分字符串，取拆分后的后半段就是小数部分的数字序列；
3. 把拆分后的字符串转成int类型（如果需要存储数值），或者直接输出该字符串（如果需要保留前导零格式）。

代码示例： #

import java.text.DecimalFormat;

public class DecimalPartExtractor {
    public static void main(String[] args) {
        double a = 0.75;
        double b = 3231.0131;
        double c = 12.033;

        // 定义格式：#匹配任意数字，后面的#数量控制最多保留的小数位数，可按需调整
        DecimalFormat df = new DecimalFormat("#.################");

        // 处理a=0.75
        String aStr = df.format(a);
        String[] aParts = aStr.split("\\.");
        int m = Integer.parseInt(aParts[1]);
        System.out.println("m（整数存储值） = " + m); // 输出：m（整数存储值） = 75
        System.out.println("m（带原始格式） = " + aParts[1]); // 输出：m（带原始格式） = 75

        // 处理b=3231.0131
        String bStr = df.format(b);
        String[] bParts = bStr.split("\\.");
        int n = Integer.parseInt(bParts[1]);
        System.out.println("n（整数存储值） = " + n); // 输出：n（整数存储值） = 131
        System.out.println("n（带原始格式） = " + bParts[1]); // 输出：n（带原始格式） = 0131

        // 处理c=12.033
        String cStr = df.format(c);
        String[] cParts = cStr.split("\\.");
        int y = Integer.parseInt(cParts[1]);
        System.out.println("y（整数存储值） = " + y); // 输出：y（整数存储值） = 33
        System.out.println("y（带原始格式） = " + cParts[1]); // 输出：y（带原始格式） = 033
    }
}

注意事项： #

• 如果输入的是整数（比如5.0），拆分后数组只有1个元素，记得加判断避免数组越界：if (parts.length > 1) { /* 处理小数部分 */ } else { /* 小数部分为0 */ }；
• DecimalFormat的格式串可以根据需求调整，比如最多保留4位小数就写#.####。

这种方法通过纯数学计算提取小数部分，适合你明确知道目标数值的小数位数的情况，但要注意浮点数的精度问题。

实现思路： #

1. 用强制类型转换提取数值的整数部分；
2. 原数减去整数部分得到纯小数部分；
3. 将小数部分乘以10^N（N是小数位数），再强制转成int得到小数部分的数值；
4. 如果需要输出带前导零的格式，用String.format()补零即可。

代码示例： #

public class DecimalMathExtractor {
    public static void main(String[] args) {
        double a = 0.75;
        double b = 3231.0131;
        double c = 12.033;

        // 处理a=0.75（2位小数）
        int intPartA = (int) a;
        double decimalPartA = a - intPartA;
        int m = (int) (decimalPartA * 100);
        System.out.println("m = " + m); // 输出：m = 75

        // 处理b=3231.0131（4位小数）
        int intPartB = (int) b;
        double decimalPartB = b - intPartB;
        int n = (int) (decimalPartB * 10000);
        System.out.println("n = " + n); // 输出：n = 131
        System.out.println("n（带前导零） = " + String.format("%04d", n)); // 输出：n（带前导零） = 0131

        // 处理c=12.033（3位小数）
        int intPartC = (int) c;
        double decimalPartC = c - intPartC;
        int y = (int) (decimalPartC * 1000);
        System.out.println("y = " + y); // 输出：y = 33
        System.out.println("y（带前导零） = " + String.format("%03d", y)); // 输出：y（带前导零） = 033
    }
}

局限性： #

• 必须预先知道小数位数，否则无法确定乘以10^N的N值；
• 浮点数精度问题：比如double d = 0.1;，d - (int)d得到的实际是0.10000000000000009，乘以10后取整虽然结果是1，但复杂数值可能出现误差，所以这种方法不如字符串处理法精准。

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