Combien de décimales dans un double (Java)

Non, il n'y a pas de fonction intégrée que je connaisse.

Il y a un moyen simple de le faire, cependant. Double.Tostring vous donnera une chaîne contenant tous les chiffres décimaux significatifs dans le double. Voici quelques propriétés de cette chaîne:

• la chaîne que les résultats peuvent être en notation décimale ou scientifique Notation, en fonction de la valeur du double.
• doubles qui convertissent des décimales de 10 000 000 ou plus ou plus petites que 1/1000 résultat en notation scientifique. Sinon, ils sont en décimal Notation.

  Utiliser Double.Tostring Pour comprendre le nombre de décimaux, il comprend essentiellement combien de chiffres significatifs à droite du point décimal moins une exposant de notation scientifique, s'il y en a un. La notation décimale aura toujours au moins un chiffre à droite du point décimal et au moins un chiffre à gauche du point décimal, même s'il s'agit d'un zéro. Puisque nous sommes préoccupés par des lieux décimaux pour des chiffres significatifs, un zéro traînant au droit du point décimal est une préoccupation et ne doit pas être compté comme un lieu décimal.

  Le code suivant passera un bon calcul pour vous: xxx

  J'ai quelques questions sur la question posée. Quel type de précision est attendu avec la représentation décimale d'un double? Les doubles sont-ils utilisés pour effectuer de manière inappropriée des calculs décimaux? Les calculs décimaux avec des fractions décimales utilisant des flotteurs et des doubles peuvent avoir des résultats présentant de manière inattendue 16 ou 17 chiffres significatifs et ne sont peut-être que des approximations des résultats attendus des calculs décimaux équivalents.

  Un aspect du flotteur, des doubles, de longs doubles (AKA quads) qui semble programmer des programmeurs et des concepteurs Stymie sont que tous ces formats sont réellement stockés en tant que nombres fractionnaires binaires qui ne peuvent que des nombres décimaux approximatifs que pour un très, Très peu de chiffres, dont la plupart sont assez proches des valeurs 1, -1, plus la valeur zéro. Comme on progresse vers l'infini positif ou zéro de 1, ou vers l'infini négatif ou zéro de -1, la portée de l'approximation deviendra apparente.

  Presque toutes les fractions décimales n'ont aucune représentation directe dans les flotteurs et les doubles. Seules des fractions décimales pouvant être comprises à partir de la somme d'une combinaison de la série de fractions suivante ont une représentation exacte:

  1, 1/2, 1/4, 1/8, 1/16, 1 / 32, 1/64, 1/128, 1/256, ..., 1/4503599627370496

  Tous les autres sont des approximations.

  entiers supérieurs à +9007199254740992 ou moins de -9007199254740992 Peut ne pas avoir une représentation exacte et la paternité augmente de manière exponentielle car les entiers augmentent au-dessus de la valeur positive ou de diminution inférieure aux valeurs négatives, respectivement.

  Une autre façon de regarder cela est de réaliser que IEEE 64 bits doubles , Normalisé, approximatif, des nombres décimaux positifs et négatifs positifs et négatifs ayant des valeurs absolues allant de 2.225073858507201400 E -308 à 1.797693134862315700 E +308. Cependant, il n'y a que des valeurs 1.84446744073709551616 E +19 disponibles pour ces approximations. Cela signifie environ 1,0 E +607 Valeurs décimales Partager une représentation avec d'autres valeurs décimales qui sont plus étroitement approchées d'un double.

  Le comportement des flotteurs et des doutes en doule des ravages avec des calculs décimaux nécessitant une précision décimale exacte, telle En tant que calculs financiers et que c'est pourquoi, sauf si une approximation de haute précision n'est acceptable, il faut utiliser des entiers à échelle et des longs, ou des classes telles que BigInteger et BigDecimal, pour des calculs nécessitant une précision décimale exacte, une arrondi et une précision.

// ****************************************************************
public int getDecimals(double doubleValue) {
// ****************************************************************
    BigDecimal bd1 = new BigDecimal(Double.toString(doubleValue)).stripTrailingZeros();
    return bd1.scale();
}

StringBuffer stringBuffer = new StringBuffer(Double.toString(ratioGrossYield));
int i; // general purpose character index
int exponent;
int decimalPlaces;
if ((i = stringBuffer.indexOf("E")) > -1) { // scientific notation...
    // turn scientific notation exponent into an integer
    exponent = Integer.parseInt(stringBuffer.substring(i + 1));
    // truncate the exponent from the StringBuffer
    stringBuffer = stringBuffer.delete(i, stringBuffer.length());
} else { // decimal notation, could be trailing zero
    exponent = 0; // no exponent, so zero
    // point i to trailing zero and truncate it, if there is one
    if (stringBuffer.charAt((i = stringBuffer.length() - 1)) == '0') {
        stringBuffer = stringBuffer.deleteCharAt(i); // delete trailing zero
    }
}
// stringBuffer now contains only significant digits to the
// right of the decimal point, if there are any
decimalPlaces = stringBuffer.length() - 1 - stringBuffer.indexOf(".") - exponent;
// zero or positive number is decimal places
// negative number is number of zeroes to the left of the decimal point
// between the decimal point and the least significant digit
if (stringBuffer.charAt(stringBuffer.length() - 1) == '0') {

    return decimalPlaces-1;

} else {

    return decimalPlaces;
}

De nombreuses années il y a de nombreuses années, je me souviens d'une réponse de 16 chiffres, au total d'avant et après le point décimal.

J'ai écrit un petit peu de code pour tester cela. P>

public class test {
    public static void main(String[] args) {
        double x;`enter code here`
        x = 3411.999999999999;
        System.out.println("16: "+x);   // gives 3411.999999999999
        x = 3411.9999999999999;
        System.out.println("17: "+x);   // gives 3412.0
        x = 0.9999999999999999;
        System.out.println("16: "+x);   // gives 0.9999999999999999
        x = 0.99999999999999999;
        System.out.println("17: "+x);   // gives 1.0
    }  
}