双倍到 Int，动态删除精度点 [关闭]

假设您要保留所有有效数字，您应该使用 BigDecimal 进行转换和转换，而不会丢失信息：

import java.math.BigDecimal;

public class MyClass {
    public static void main(String args[]) {
      BigDecimal x=BigDecimal.valueOf(1.12345);
      int y=x.unscaledValue().intValueExact();
      System.out.println("y = " + y);
    }
}

输出：

y = 112345

valueOf()需要从浮点类型创建 BigDecimal，而不会出现表示错误。 如果结果超出 的范围，将引发异常。intValueExact()int

请注意，此解决方案将 5 保留在数字的末尾，这与示例不同。

如果您知道要在小数部分后保留多少位数字，则可以乘以 10^n 并将结果存储在 int 中。

使用浮点存储双精度的方式始终是数字的近似值。就像其他人说的，这意味着 1.1 不能准确表示，实际值更接近 1.100000000000000088817841970012523233890533447265625

如果我们知道您试图通过这种数据转换实现什么，也许我们可以提供不同的替代方案？因为这是一件非常奇怪的事情，我想不出为什么您需要在任何应用程序中执行此操作的原因。

BigDecimal 绝对是要走的路，但是，如果您想要另一种选择，您可以做这样的事情......

• 将 double 类型值转换为字符串;
• 删除小数点（无论它是什么类型）;
• 将字符串转换为长整型数据类型;
• 查看 long 值是否大于或等于 Integer.MIN_VALUE 或者，小于或等于整数.MAX_VALUE。如果是，则将 long 值转换为 int。如果不是，则删除单个尾随数字 从长整型值并再次检查。继续检查，直到很久 value 位于 Integer.MIN_VALUE 和 Integer.MAX_VALUE 范围内。

下面是一个代码示例。请务必阅读评论：

/* Double type values to convert in double type array. 
   You could potentially supply signed values as well.
   The decimal point identifier can be whatever suits 
   your specific system locale (. or ,):    */
double[] dblArray = {1.1234567896543217d, 1.123d, 1.1d, 
    1.1001, -1.10017887643456776d, 1.12345d, 0.12345d, 
    87.543276d, 4657.439802};

/* Display a table header in Console for the conversion results 
   from the double type array to int values. The String.format()
   method is used:        */
System.out.println("Remove decimal point and convert to int:\n");
System.out.println(String.format("%-25s %-12s", "Double (double)", "Integer (int)"));
System.out.println("=======================================");

/* Convert each double type element within the dblArray[] array
   to int ans display the results in a Table style format:   */
boolean greaterThanMinMaxInt;   // Flag
for (Double dbl : dblArray) {
    greaterThanMinMaxInt = false; // Used only for display purposes.
    /* First convert the double type data to an long type value
       by converting the double type value to String then removing 
       the decimal point (be it '.' or ',') then using the known 
       Long.parseLong() method to convert the new string value to 
       a long data type. This is done to ensure the the double 
       value conversion will fit and we can then check for Integer
       MIN/MAX.             */
    long lng = Long.parseLong(String.valueOf(dbl).replaceAll("[.,]", ""));

    /* Is the long type value less than Integer.MIN_VALUE or greater 
       than Integer.MAX_VALUE. If it is then remove a digit from the 
       trailing end of the long type value. Keep doing this until the 
       long value falls within bounds:         */
    while (lng < Integer.MIN_VALUE || lng > Integer.MAX_VALUE) {
        lng = lng / 10; // Remove last digit in long value.
        greaterThanMinMaxInt = true; // Flag set - Value needed reducing.
    }

    /* Now that the long type value is within Integer.MIN/MAX 
       values, convert the value to `int`:   */
    int intValue = (int) lng;

    /* Display the result within Console Table. Nested Ternary 
       Operators are used to display which values were actually 
       reduced in length to satisfy Integer.MIN_VALUE and 
       Integer.MAX_VALUE:  */
    System.out.println(String.format("%-25s %-12s", String.valueOf(dbl), 
            String.valueOf(intValue) + (greaterThanMinMaxInt ? (intValue > 0 
                    ? " ('Had' Integer.MAX_VALUE Overflow)" : " ('Had' Integer.MIN_VALUE Overflow)") 
                    : "")));
}

如果运行上述代码，则应在“控制台窗口”中看到以下内容：

Remove decimal point and convert to int:

Double (double)           Integer (int)
=======================================
1.1234567896543217        1123456789 ('Had' Integer.MAX_VALUE Overflow)
1.123                     1123        
1.1                       11          
1.1001                    11001       
-1.1001788764345677       -1100178876 ('Had' Integer.MIN_VALUE Overflow)
1.12345                   112345      
0.12345                   12345       
87.543276                 87543276    
4657.439802               465743980 ('Had' Integer.MAX_VALUE Overflow)