Java DecimalFormat потери точности при форматировании двойной

Question

Когда я выполнить следующий код:

public class Test { 
    public static void main(String args[]){ 
     DecimalFormat format = new DecimalFormat(); 
     Double value = new Double(-1350825904190559999913623552.00); 

     StringBuffer buffer = new StringBuffer(); 
     FieldPosition position = new FieldPosition(0); 
     format.format(new BigDecimal(value), buffer, position); 
     System.out.println(buffer); 
    } 
} 

Это правильно печатает -1,350,825,904,190,559,999,913,623,552. У меня есть код, который проходит через много двойников, поэтому я не хочу, чтобы преобразование из double в bigdecimal. Я понял, что время обработки BigDecimal велико. Так что я делаю format.format(value, buffer, position) И я вижу, что точность потеряна. Выход я получаю -1,350,825,904,190,560,000,000,000,000.

Что я здесь делаю неправильно? Есть ли лучший способ справиться с этим и сохранить точность. Я не хочу иметь дело с BigDecimals, но просто работаю с десятичными знаками.

Любые предложения?

Answer 1

double не имеет бесконечную точность, и вы не можете получить более высокую точность, чем double имеет путем преобразования double в BigDecimal (как вы не можете получить более высокую точность с int, когда вы делаете double r = 1/3; который 0.0 потому что он расширяет a int до double). Вместо этого вы можете использовать String. Что-то вроде

DecimalFormat format = new DecimalFormat(); 
String value = "-1350825904190559999913623552.00"; 
System.out.println(format.format(new BigDecimal(value))); 

Answer 2

Вы не можете представить 1350825904190559999913623552.00 точно с Double. Если вы хотите узнать, почему, изучите это article.

Если вы хотите представить это значение, я бы посоветовал использовать код, который вы использовали в своем вопросе: new BigDecimal(value), где value - это фактически String.

Answer 3

Он не потерян во время форматирования. Он потерял здесь:

Double value = new Double(-1350825904190559999913623552.00); 

double имеет только около 15,9 значащих десятичных цифр. Это не подходит. Во время компиляции была прецизионная потеря, когда был преобразован литерал с плавающей запятой.

Answer 4

Проблема заключается в форматировании вывода, в частности о том, как удвоения преобразуются в строки по умолчанию. Каждое двойное число имеет точное значение, но оно также является результатом преобразования строки в двойное преобразование для диапазона десятичных дробей. В этом случае точное значение двойного значения составляет -1350825904190559999913623552, но диапазон составляет [-1350825904190560137352577024, -1350825904190559862474670080].

Преобразование Double toString выбирает номер из этого диапазона с наименьшими значащими цифрами, -1.35082590419056E27. Эта строка преобразует обратно в исходное значение.

Если вы действительно хотите увидеть точное значение, а не просто цифры, чтобы однозначно идентифицировать двойной, ваш текущий подход BigDecimal работает хорошо.

Вот программа, которую я использовал для расчета чисел в этом ответе:

import java.math.BigDecimal; 

public class Test { 
    public static void main(String args[]) { 
    double value = -1350825904190559999913623552.00; 
    /* Get an exact printout of the double by conversion to BigDecimal 
    * followed by BigDecimal output. Both those operations are exact. 
    */ 
    BigDecimal bdValue = new BigDecimal(value); 
    System.out.println("Exact value: " + bdValue); 
    /* Determine whether the range is open or closed. The half way 
    * points round to even, so they are included in the range for a number 
    * with an even significand, but not for one with an odd significand. 
    */ 
    boolean isEven = (Double.doubleToLongBits(value) & 1) == 0; 
    /* Find the lower bound of the range, by taking the mean, in 
    * BigDecimal arithmetic for exactness, of the value and the next 
    * exactly representable value in the negative infinity direction. 
    */ 
    BigDecimal nextDown = new BigDecimal(Math.nextAfter(value, 
     Double.NEGATIVE_INFINITY)); 
    BigDecimal lowerBound = bdValue.add(nextDown).divide(BigDecimal.valueOf(2)); 
    /* Similarly, find the upper bound of the range by going in the 
    * positive infinity direction. 
    */ 
    BigDecimal nextUp = new BigDecimal(Math.nextAfter(value, 
     Double.POSITIVE_INFINITY)); 
    BigDecimal upperBound = bdValue.add(nextUp).divide(BigDecimal.valueOf(2)); 
    /* Output the range, with [] if closed,() if open.*/ 
    System.out.println("Range: " + (isEven ? "[" : "(") + lowerBound + "," 
     + upperBound + (isEven ? "]" : ")")); 
    /* Output the result of applying Double's toString to the value.*/ 
    String valueString = Double.toString(value); 
    System.out.println("toString result: " + valueString); 
    /* And use BigDecimal as above to print the exact value of the result 
    * of converting the toString result back again. 
    */ 
    System.out.println("exact value of toString result as double: " 
     + new BigDecimal(Double.parseDouble(valueString))); 
    } 
} 

Выход:

Exact value: -1350825904190559999913623552 
Range: [-1350825904190560137352577024,-1350825904190559862474670080] 
toString result: -1.35082590419056E27 
exact value of toString result as double: -1350825904190559999913623552