À L'Aide De Java Double.toString() de mise en forme de style avec plus de chiffres (DecimalFormat ne fonctionne pas avec une faible précision des nombres)

Le problème central est que j'ai une série de doubles que j'ai besoin de vous connecter, chacun avec nombre variable de chiffres significatifs. Les chiffres varient considérablement dans combien de chiffres significatifs qu'ils ont. Certains ont 0 (p. 5257), certains en ont 2 (par exemple 1308.75), certains ont tout le chemin jusqu'à 7 (par ex. 124.1171875). Fondamentalement, tout ce qui est entre 0 à 7 chiffres significatifs après la virgule.

Double Standard.toString() fonctionne super sur tout, MAIS ceux avec 7 chiffres significatifs. C'est tout le chemin jusqu'à 6 chiffres, les chiffres significatifs sont tous imprimés sans chiffres insignifiants. Mais sur ceux avec 7 chiffres significatifs, toString() arrondit le dernier chiffre. I. e.

5257 -> "5257"
1308.75 -> "1308.75"
124.1171875 -> "124.117188"

Bien sûr, j'ai essayé d'utiliser DecimalFormat("#.#######"), et qui a résolu le problème de manque de chiffres significatifs, mais il imprimé chiffres insignifiants pour beaucoup de la faible précision double. I. e.

1308.75 -> "1308.7499998"

C'est tout aussi inacceptable que 1) il gaspille une quantité importante d'espace (généralement log >2 GO de données par jour) et 2) il bousille les applications utilisant les journaux.

DecimalFormat semble sucer par rapport à toString() quand il s'agit de l'identification de chiffres significatifs, est-il de toute façon à résoudre ce problème? Je veux juste utiliser toString() de style de la manipulation de chiffres significatifs, et d'étendre le nombre maximum de chiffres de 6 à 7.

Des idées?
Grâce

Strictement parlant "5257" a 4 chiffres significatifs, je pense que vous vouliez dire "chiffres significatifs après la virgule".

OriginalL'auteur user79126 | 2011-07-29

  1. 7

    Si vous êtes soucieux de la préservation des valeurs décimales exactement, vous devez utiliser BigDecimal pour commencer - double est fondamentalement inapproprié, comme un binaire type à virgule flottante.

    Comme il arrive, je ne peux pas reproduire le comportement de 1308.75 dans DecimalFormat, ce qui ne m'étonne pas parce que la valeur est exactement représentable comme un double. En fait, DecimalFormat semble être l'application de certaines heuristiques de toute façon, même 1308.76 sort 1308.76 - ce qui me surprend le réelle valeur est 1308.759999999999990905052982270717620849609375. Cela signifie que si vous utilisez 1308.7599999999999 dans votre code, il va sortir comme 1308.76, parce que c'est exactement la même valeur que double. Si vous avez besoin de faire la distinction entre ces deux valeurs, vous devez certainement être en utilisant BigDecimal.

    Également noter que 1308.75 a 6 chiffres significatifs - il y a 2 décimales. Il vaut la peine d'être attentif à la différence entre les deux concepts.

    OriginalL'auteur Jon Skeet

  2. 3

    Il me semblait un peu étrange, c'est pourquoi je suis sorti et testé.
    J'ai essayé ce code:

    public class MySimpleTest
{
    public static void main(String args[])
    {
        format(5257);
        format(1308.75);
        format(124.1171875);
    }

    private static void format(double d)
    {
        DecimalFormat df = new DecimalFormat("##.#######");
        System.out.println("" + d + " -> " + df.format(d));
    }
}

    Et il m'a donné ce résultat:

    5257.0 -> 5257
1308.75 -> 1308.75
124.1171875 -> 124.1171875

    Vous avez probablement été à des essais avec "##.######" (seulement 6 #s après le point), ou de votre numéro pourrait avoir des chiffres de fin. Le point est que ##.####### et ##.0000000 formats round, le dernier point décimal (par exemple, 124.11718755 sera arrondi à 124.1171876 avant le formatage). Si vous voulez qu'il soit tronqué essayer de le tronquer tout d'abord, de faire quelque chose comme ceci:

    double d = 124.1171875999999;
org.apache.commons.math.util.MathUtils.round(d, 6, java.math.BigDecimal.ROUND_DOWN);
DecimalFormat df = new DecimalFormat("##.#######");
System.out.println("" + d + " -> " + df.format(d));

    OriginalL'auteur n0rm1e

  3. -1

    En plus de ce que Jon Skeet mentionné, pourquoi ne pas garder un tableau de DecimalFormat, chacun fo un certain nombre de chiffres?

    OriginalL'auteur Tassos Bassoukos